mybatis-plus:
  global-config:
    db-config:
      logic-delete-field: isDelete #默认deleted
      logic-delete-value: 1
      logic-not-delete-value: 0
      id-type: auto

@Data
public class User{
。。。
    /**
     * 1删除0正常
     */
    @TableLogic(value = "1",delval = "0")
    private Integer isDelete;
。。。
}

@Configuration
@MapperScan("scan.your.mapper.package")
public class MybatisPlusConfig {

    /**
     * 添加分页插件
     */
    @Bean
    public MybatisPlusInterceptor mybatisPlusInterceptor() {
        MybatisPlusInterceptor interceptor = new MybatisPlusInterceptor();
        interceptor.addInnerInterceptor(new PaginationInnerInterceptor(DbType.MYSQL)); // 如果配置多个插件, 切记分页最后添加
        // 如果有多数据源可以不配具体类型, 否则都建议配上具体的 DbType
        return interceptor;
    }
}

<dependency>  
    <groupId>com.github.binarywang</groupId>  
    <artifactId>weixin-java-miniapp</artifactId>  
</dependency>

@Component
@Data
//从配置文件中读取 wx.miniapp 前缀下的字段
@ConfigurationProperties(prefix = "wx.miniapp")
public class WxConfigProperties {
    private String appId;
    private String secret;
}

@Component
public class WxConfigOperator {

    @Autowired
    private WxConfigProperties wxConfigProperties;

    @Bean
    public WxMaService wxMaService() {
        WxMaDefaultConfigImpl config = new WxMaDefaultConfigImpl();
        config.setAppid(wxConfigProperties.getAppId());
        config.setSecret(wxConfigProperties.getSecret());

        WxMaService service = new WxMaServiceImpl();
        service.setWxMaConfig(config);
        return service;
    }
}

@Slf4j
@RestController
@RequestMapping("/customer/info")
@SuppressWarnings({"unchecked", "rawtypes"})
public class CustomerInfoController {

	@Autowired
	private CustomerInfoService customerInfoService;

	// 微信小程序登录接口
	@Operation(summary = "小程序授权登录")
	@GetMapping("login/{code}")
	public Result<Long> longin(@PathVariable String code) {
	    return Result.ok(customerInfoService.login(code));
	}
}

@Slf4j
@Service
@SuppressWarnings({"unchecked", "rawtypes"})
public class CustomerInfoServiceImpl extends ServiceImpl<CustomerInfoMapper, CustomerInfo> implements CustomerInfoService {

    @Autowired
    private WxMaService wxMaService;

    @Autowired
    private CustomerInfoMapper customerInfoMapper;

    @Autowired
    private CustomerLoginLogMapper customerLoginLogMapper;

    //微信小程序登录
    @Override
    public Long login(String code) {
        String openid = null;
        // 获取code值，通过微信工具包对象，获取唯一标识openId
        try {
            WxMaJscode2SessionResult sessionInfo = wxMaService.getUserService().getSessionInfo(code);
             openid = sessionInfo.getOpenid();
        } catch (WxErrorException e) {
            throw new RuntimeException(e);
        }

        // 用openId查询数据库是否存在
        // 如果openId不存在返回null，如果存在返回记录
        LambdaQueryWrapper<CustomerInfo> wrapper = new LambdaQueryWrapper();
        wrapper.eq(CustomerInfo::getWxOpenId, openid);
        CustomerInfo customerInfo = customerInfoMapper.selectOne(wrapper);

        // 如果不存在，也就是第一次登陆，添加信息到用户表
        if (customerInfo == null) {
            customerInfo = new CustomerInfo();
            //用当前时间戳作为昵称
            customerInfo.setNickname(String.valueOf(System.currentTimeMillis()));
            //设置默认头像
            customerInfo.setAvatarUrl("https://oss.aliyuncs.com/aliyun_id_photo_bucket/default_handsome.jpg");
            //把openId存入用户表
            customerInfo.setWxOpenId(openid);
            customerInfoMapper.insert(customerInfo);
        }

        // 记录登录日志
        CustomerLoginLog loginLog = new CustomerLoginLog();
        loginLog.setCustomerId(customerInfo.getId());
        loginLog.setMsg("小程序登录");
        customerLoginLogMapper.insert(loginLog);

        // 最后返回用户id
        return customerInfo.getId();
    }
}

@FeignClient(value = "service-customer")
public interface CustomerInfoFeignClient {

    @GetMapping("/customer/info/login/{code}")
    public Result<Long> longin(@PathVariable String code);
    
}

@Slf4j
@Tag(name = "客户API接口管理")
@RestController
@RequestMapping("/customer")
@SuppressWarnings({"unchecked", "rawtypes"})
public class CustomerController {

    @Autowired
    private CustomerService customerInfoService;

    @Operation(summary = "小程序授权登录")
    @GetMapping("/login/{code}")
    public Result<String> wxLogin(@PathVariable String code) {
        return Result.ok(customerInfoService.login(code));
    }
}

@Slf4j
@Service
@SuppressWarnings({"unchecked", "rawtypes"})
public class CustomerServiceImpl implements CustomerService {

    // 注入远程调用
    @Autowired
    private CustomerInfoFeignClient client;

    @Autowired
    private RedisTemplate redisTemplate;

    @Override
    public String login(String code) {

        // 拿着code进行远程调用，返回用户id
        Result<Long> longin = client.longin(code);

        // 如果返回失败了。返回错误信息
        Integer code1 = longin.getCode();
        if(code1 != 200){
            throw new GuiguException(ResultCodeEnum.DATA_ERROR);
        }

        // 获取远程调用的用户id
        Long customerId = longin.getData();

        // 判断返回用户id是否为空，为空则返回错误提示
        if(customerId == null){
            throw new GuiguException(ResultCodeEnum.DATA_ERROR);
        }

        // 把用户id放到Redis中，设置过期时间
        String token = UUID.randomUUID().toString();

        // 返回token
        redisTemplate.opsForValue().set(RedisConstant.USER_LOGIN_KEY_PREFIX+token,
                customerId.toString(),
                RedisConstant.USER_LOGIN_KEY_TIMEOUT,
                TimeUnit.SECONDS);
        return token;
    }
}

@Operation(summary = "获取客户端登录信息")
	@GetMapping("/getCustomerLoginInfo/{customerId}")
	public Result<CustomerLoginVo> getCustomerLoginInfo(@PathVariable Long customerId) {
		CustomerLoginVo customerLoginVo = customerInfoService.getCustomerInfoService(customerId);
		return Result.ok(customerLoginVo);
	}

@Override
    public CustomerLoginVo getCustomerInfoService(Long customerId) {

        // 根据用户id查询用户信息
//        LambdaQueryWrapper<CustomerInfo> wrapper = new LambdaQueryWrapper();
//        wrapper.eq(CustomerInfo::getId, customerId);
//        CustomerInfo customerInfo = customerInfoMapper.selectOne(wrapper);
        CustomerInfo info = customerInfoMapper.selectById(customerId);
        if (info == null) {
            throw new RuntimeException("用户不存在");
        }

        // 封装到customerLoginVo对象
        CustomerLoginVo customerLoginVo = new CustomerLoginVo();

        // springboot的工具类，可以把第一个对象的属性复制到第二个对象的同名属性中
        BeanUtils.copyProperties(info, customerLoginVo);

        /*
        * 还有一个属性需要手动拷贝，判断是否存在手机号
        * StringUtils.hasText(info.getPhone())判断字符串是否有值
        */
        customerLoginVo.setIsBindPhone(StringUtils.hasText(info.getPhone()));

        // 返回对象
        return customerLoginVo;
    }

@Operation(summary = "获取客户登录信息")
@GetMapping("/getCustomerLoginInfo")
public Result<CustomerLoginVo> getCustomerLoginInfo(@RequestHeader(value = "token") String token) {

	CustomerLoginVo customerLoginVo = customerInfoService.getCustomerLoginInfo(token);
	// 返回用户对象
	return Result.ok(customerLoginVo);
}

@Override
public CustomerLoginVo getCustomerLoginInfo(String token) {
	/*
	 * 从请求头中获取token字符串
	 * 根据token查询redis
	 */
	String customerId = (String) redisTemplate.opsForValue().get(RedisConstant.USER_LOGIN_KEY_PREFIX+token);

	// 根据用户id进行远程调用，获取用户信息
	if(!StringUtils.hasText(customerId)){
		throw new GuiguException(ResultCodeEnum.DATA_ERROR);
	}

	Result<CustomerLoginVo> customerLoginInfo = client.getCustomerLoginInfo(Long.parseLong(customerId));
	Integer code = customerLoginInfo.getCode();
	if(code != 200){
		throw new GuiguException(ResultCodeEnum.DATA_ERROR);
	}
	CustomerLoginVo data = customerLoginInfo.getData();
	if(data == null){
		throw new GuiguException(ResultCodeEnum.DATA_ERROR);
	}
	return data;
}

@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
public @interface LoginDetection {
    
}

@Component
@Aspect
public class LoginAspect {

    @Autowired
    private RedisTemplate redisTemplate;

    // 环绕通知，运行前后都触发
    // 切入点表达式，用来指定那些规则的方法进行增强
    @Around("execution(* com.atguigu.daijia.*.controller.*.*(..)) && @annotation(loginDetection)")
    public Object login(ProceedingJoinPoint proceedingJoinPoint,
                        LoginDetection loginDetection) throws Throwable {

        // 获取request对象，并且从请求头获取token
        RequestAttributes requestAttributes = RequestContextHolder.getRequestAttributes();
        ServletRequestAttributes sra = (ServletRequestAttributes) requestAttributes;

        String token = sra.getRequest().getHeader("token");


        // 判断token是否有效，如果为空或过期，返回登录提示
        if(!StringUtils.hasText(token)){
            throw new GuiguException(ResultCodeEnum.LOGIN_AUTH);
        }

        // token不为空，查询redis、对应用户id，把用户id放到ThreadLocal里面
        String customerId = (String) redisTemplate.opsForValue().get(RedisConstant.USER_LOGIN_KEY_PREFIX + token);
        
        if(StringUtils.hasText(customerId)){
            AuthContextHolder.setUserId(Long.parseLong(customerId));
        }
        
        // 执行目标方法
        return proceedingJoinPoint.proceed();
    }
}

@Operation(summary = "获取客户登录信息")
    @LoginDetection
    @GetMapping("/getCustomerLoginInfo")
    public Result<CustomerLoginVo> getCustomerLoginInfo() {

        // 从ThreadLocal获取用户id
        Long userId = AuthContextHolder.getUserId();

        // 调用service
        CustomerLoginVo customerLoginVo = customerInfoService.getCustomerInfo(userId);

        // 返回用户对象
        return Result.ok(customerLoginVo);
    }

@Override
public CustomerLoginVo getCustomerInfo(Long customerId) {

	Result<CustomerLoginVo> customerLoginInfo = client.getCustomerLoginInfo(customerId);
	Integer code = customerLoginInfo.getCode();
	if(code != 200){
		throw new GuiguException(ResultCodeEnum.DATA_ERROR);
	}
	CustomerLoginVo data = customerLoginInfo.getData();
	if(data == null){
		throw new GuiguException(ResultCodeEnum.DATA_ERROR);
	}
	return data;
}

@Operation(summary = "更新客户微信手机号码")
@PostMapping("/updateWxPhoneNumber")
public Result<Boolean> updateWxPhoneNumber(@RequestBody UpdateWxPhoneForm updateWxPhoneForm) {
	return Result.ok(customerInfoService.updateWxPhoneNumber(updateWxPhoneForm));
}

// 更新客户微信手机号码
@Override
public Boolean updateWxPhoneNumber(UpdateWxPhoneForm updateWxPhoneForm) {

	// 根据code查询用户信息
	try {
		WxMaPhoneNumberInfo phoneNoInfo = wxMaService.getUserService().getPhoneNoInfo(updateWxPhoneForm.getCode());

		// 更新用户信息
		Long customerId = updateWxPhoneForm.getCustomerId();
		CustomerInfo customerInfo = customerInfoMapper.selectById(customerId);
		customerInfo.setPhone(phoneNoInfo.getPhoneNumber());
		customerInfoMapper.updateById(customerInfo);

		return true;
	} catch (WxErrorException e) {
		throw new RuntimeException(e);
	}
}

@Operation(summary = "更新用户微信手机号")
@LoginDetection
@PostMapping("/updateWxPhone")
public Result updateWxPhone(@RequestBody UpdateWxPhoneForm updateWxPhoneForm) {
	updateWxPhoneForm.setCustomerId(AuthContextHolder.getUserId());
	return Result.ok(customerInfoService.updateWxPhoneNumber(updateWxPhoneForm));
}

@Operation(summary = "更新用户微信手机号")
@LoginDetection
@PostMapping("/updateWxPhone")
public Result updateWxPhone(@RequestBody UpdateWxPhoneForm updateWxPhoneForm) {
	updateWxPhoneForm.setCustomerId(AuthContextHolder.getUserId());
	return Result.ok(true);
}

@Override
public boolean updateWxPhoneNumber(UpdateWxPhoneForm updateWxPhoneForm) {
	Result<Boolean> booleanResult = client.updateWxPhoneNumber(updateWxPhoneForm);
	return true;
}

@Component
@Data
@ConfigurationProperties(prefix = "wx.miniapp")
public class WxConfigProperties {
    private String appId;
    private String secret;
}

@Component
public class WxConfigOperator {

    @Autowired
    private WxConfigProperties wxConfigProperties;

    @Bean
    public WxMaService wxMaService() {
        //微信小程序id和秘钥
        WxMaDefaultConfigImpl wxMaConfig = new WxMaDefaultConfigImpl();
        wxMaConfig.setAppid(wxConfigProperties.getAppId());
        wxMaConfig.setSecret(wxConfigProperties.getSecret());
        WxMaService service = new WxMaServiceImpl();
        service.setWxMaConfig(wxMaConfig);
        return service;
    }
}

@Slf4j
@Tag(name = "司机API接口管理")
@RestController
@RequestMapping(value="/driver/info")
@SuppressWarnings({"unchecked", "rawtypes"})
public class DriverInfoController {

    @Autowired
    private DriverInfoService driverInfoService;

    @Operation(summary = "小程序授权登录")
    @GetMapping("/login/{code}")
    public Result<Long> login(@PathVariable("code") String code) {
        return Result.ok(driverInfoService.login(code));
    }
}

@Slf4j
@Service
@SuppressWarnings({"unchecked", "rawtypes"})
public class DriverInfoServiceImpl extends ServiceImpl<DriverInfoMapper, DriverInfo> implements DriverInfoService {

    @Autowired
    private WxMaService wxMaService;

    @Autowired
    private DriverInfoMapper driverInfoMapper;

    @Autowired
    private DriverSetMapper driverSetMapper;

    @Autowired
    private DriverAccountMapper driverAccountMapper;

    @Autowired
    private DriverLoginLogMapper driverLoginLogMapper;

    // 小程序授权登录
    @Override
    public Long login(String code) {
        try {
            // 通过code+密钥+小程序id获取用户唯一标识openid
            WxMaJscode2SessionResult sessionInfo = wxMaService.getUserService().getSessionInfo(code);
            String openid = sessionInfo.getOpenid();

            // 根据openid查询用户信息
            LambdaQueryWrapper<DriverInfo> wrapper = new LambdaQueryWrapper<>();
            wrapper.eq(DriverInfo::getWxOpenId, openid);
            DriverInfo driverInfo = driverInfoMapper.selectOne(wrapper);

            if(driverInfo == null){
                // 添加司机基本信息
                driverInfo = new DriverInfo();
                driverInfo.setNickname(String.valueOf(System.currentTimeMillis()));
                driverInfo.setAvatarUrl("https://oss.aliyuncs.com/aliyun_id_photo_bucket/default_handsome.jpg");
                driverInfo.setWxOpenId(openid);
                driverInfoMapper.insert(driverInfo);

                // 初始化司机设置
                DriverSet driverSet = new DriverSet();
                driverSet.setDriverId(driverInfo.getId());
                driverSet.setOrderDistance(new BigDecimal(0));//0：无限制
                driverSet.setAcceptDistance(new BigDecimal(SystemConstant.ACCEPT_DISTANCE));//默认接单范围：5公里
                driverSet.setIsAutoAccept(0);//0：否 1：是
                driverSetMapper.insert(driverSet);

                // 初始化司机账户信息
                DriverAccount driverAccount = new DriverAccount();
                driverAccount.setDriverId(driverInfo.getId());
                driverAccountMapper.insert(driverAccount);
            }

            // 更新登录日志
            DriverLoginLog loginLog = new DriverLoginLog();
            loginLog.setDriverId(driverInfo.getId());
            loginLog.setMsg("小程序登录");
            driverLoginLogMapper.insert(loginLog);

            // 返回用户id
            return driverInfo.getId();
        } catch (WxErrorException e) {
            throw new GuiguException(ResultCodeEnum.DATA_ERROR);
        }
    }
}

@FeignClient(value = "service-driver")
public interface DriverInfoFeignClient {

    // 小程序授权登录
    @GetMapping("/driver/info/login/{code}")
    public Result<Long> login(@PathVariable("code") String code);
}

@Slf4j
@Tag(name = "司机API接口管理")
@RestController
@RequestMapping(value="/driver")
@SuppressWarnings({"unchecked", "rawtypes"})
public class DriverController {

    @Autowired
    private DriverService driverService;

    @Operation(summary = "小程序授权登录")
    @GetMapping("/login/{code}")
    public Result<String> login(@PathVariable("code") String code) {
        return Result.ok(driverService.login(code));
    }
}

@Slf4j
@Service
@SuppressWarnings({"unchecked", "rawtypes"})
public class DriverServiceImpl implements DriverService {

    @Autowired
    private DriverInfoFeignClient driverInfoFeignClient;

    @Autowired
    private RedisTemplate redisTemplate;

    // 小程序授权登录
    @Override
    public String login(String code) {
        Result<Long> result = driverInfoFeignClient.login(code);
        if(result.getCode() != 200){
            throw new GuiguException(ResultCodeEnum.DATA_ERROR);
        }
        Long data = result.getData();
        if(data == null){
            throw new GuiguException(ResultCodeEnum.DATA_ERROR);
        }
        String token = UUID.randomUUID().toString().replace("-","");
        redisTemplate.opsForValue().set(RedisConstant.USER_LOGIN_KEY_PREFIX + token,
                data.toString(),
                RedisConstant.USER_LOGIN_KEY_TIMEOUT,
                TimeUnit.SECONDS);

        return token;
    }
}

@Operation(summary = "获取司机登录信息")  
@GetMapping("/getDriverLoginInfo/{driverId}")  
public Result<DriverLoginVo> getDriverInfo(@PathVariable("driverId") long driverId) {  
    DriverLoginVo driverLoginVo = driverInfoService.getDriverInfo(driverId);  
    return Result.ok(driverLoginVo);  
}

// 获取司机登录信息
@Override
public DriverLoginVo getDriverInfo(long driverId) {
	// 通过id查询司机信息
	DriverInfo driverInfo = driverInfoMapper.selectById(driverId);
	
	// 赋予到vo对象中
	DriverLoginVo driverLoginVo = new DriverLoginVo();
	BeanUtils.copyProperties(driverInfo, driverLoginVo);

	// 查询是否需要建档人脸识别
	String faceModelId = driverInfo.getFaceModelId();
	boolean isArchiveFace = StringUtils.hasText(faceModelId);
	driverLoginVo.setIsArchiveFace(isArchiveFace);
	return driverLoginVo;
}

@FeignClient(value = "service-driver")
public interface DriverInfoFeignClient {

    // 小程序授权登录
    @GetMapping("/driver/info/login/{code}")
    public Result<Long> login(@PathVariable("code") String code);

    // 获取登录司机信息
    @GetMapping("/driver/info/getDriverLoginInfo/{driverId}")
    public Result<DriverLoginVo> getDriverInfo(@PathVariable("driverId") long driverId);
}

@Operation(summary = "获取登录司机信息")
@LoginDetection
@GetMapping("/getDriverLoginInfo")
public Result<DriverLoginVo> getDriverLoginInfo() {
	return Result.ok(driverService.getDriverLoginVo());
}

@Override
public DriverLoginVo getDriverLoginVo() {
	Long driverId = AuthContextHolder.getUserId();
	Result<DriverLoginVo> driverInfo = driverInfoFeignClient.getDriverInfo(driverId);
	return driverInfo.getData();
}

@Tag(name = "上传管理接口")
@RestController
@RequestMapping("file")
public class FileController {

    @Autowired
    private CosService cosService;

    // 文件上传接口
    @Operation(summary = "上传")
    @LoginDetection
    @PostMapping("/upload")
    public Result<CosUploadVo> upload(@RequestPart("file") MultipartFile file,
                                      @RequestParam(value = "path", defaultValue = "auth") String path) {
        CosUploadVo cosUploadVo = cosService.uploadFile(file, path);
        return Result.ok(cosUploadVo);
    }
}

@Slf4j
@Service
@SuppressWarnings({"unchecked", "rawtypes"})
public class CosServiceImpl implements CosService {

    @Autowired
    private CosFeignClient cosFeignClient;

    // 文件上传接口
    @Override
    public CosUploadVo uploadFile(MultipartFile file, String path) {
        // 远程调用获取vo
        Result<CosUploadVo> result =  cosFeignClient.upload(file, path);
        CosUploadVo cosUploadVo = result.getData();
        return cosUploadVo;
    }
}

@FeignClient(value = "service-driver")
public interface CosFeignClient {

    /*
    * 文件上传
    * MediaType 表示上传类型
    */
    @PostMapping(value = "/cos/upload", consumes = MediaType.MULTIPART_FORM_DATA_VALUE)
    public Result<CosUploadVo> upload(@RequestPart("file") MultipartFile file,
                                      @RequestParam(value = "path") String path);
}

<dependency>
     <groupId>com.qcloud</groupId>
     <artifactId>cos_api</artifactId>
     <version>5.6.227</version>
</dependency>

@Data
@Component
@ConfigurationProperties(prefix = "tencent.cloud")
public class TencentCloudProperties {
    private String secretId;
    private String secretKey;
    private String region;
    private String bucketPrivate;
}

@Slf4j
@Tag(name = "腾讯云cos上传接口管理")
@RestController
@RequestMapping(value="/cos")
@SuppressWarnings({"unchecked", "rawtypes"})
public class CosController {

    @Autowired
    private CosService cosService;

    @Operation(summary = "上传")
    @PostMapping("/upload")
    public Result<CosUploadVo> upload(@RequestPart("file") MultipartFile file,
                                      @RequestParam("path") String path) {
        CosUploadVo cosUploadVo = cosService.upload(file, path);
        return Result.ok(cosUploadVo);
    }
}

@Slf4j
@Service
@SuppressWarnings({"unchecked", "rawtypes"})
public class CosServiceImpl implements CosService {

    @Autowired
    private TencentCloudProperties tencentCloudProperties;

    // 文件上传
   @Override
    public CosUploadVo upload(MultipartFile file, String path) {

        // 获取cos客户端
        COSClient cosClient = getCosClient();

        // 文件上传
        // 设置文件元数据信息
        ObjectMetadata metadata = new ObjectMetadata();
        metadata.setContentLength(file.getSize());
        metadata.setContentEncoding("UTF-8");
        metadata.setContentType(file.getContentType());

        // 向储存桶保存文件
        String fileType = file.getOriginalFilename().substring(file.getOriginalFilename().lastIndexOf(".")); //文件后缀名
        String uploadPath = "/driver/" + path + "/" + UUID.randomUUID().toString().replaceAll("-", "") + fileType;
        // 01.jpg
        // /driver/auth/0o98754.jpg
        PutObjectRequest putObjectRequest = null;
        try {
            //1 bucket名称
            //2
            putObjectRequest = new PutObjectRequest(tencentCloudProperties.getBucketPrivate(),
                    uploadPath,
                    file.getInputStream(),
                    metadata);
        } catch (IOException e) {
            throw new RuntimeException(e);
        }
        putObjectRequest.setStorageClass(StorageClass.Standard);
        PutObjectResult putObjectResult = cosClient.putObject(putObjectRequest); //上传文件
        cosClient.shutdown();

        //返回vo对象
        CosUploadVo cosUploadVo = new CosUploadVo();
        cosUploadVo.setUrl(uploadPath);
        // 图片临时访问回显url
        cosUploadVo.setShowUrl(this.getImagerUrl(uploadPath));
        return cosUploadVo;
    }

private COSClient getCosClient() {
	// 1 初始化用户身份信息（secretId, secretKey）。
	String secretId = tencentCloudProperties.getSecretId();
	String secretKey = tencentCloudProperties.getSecretKey();
	COSCredentials cred = new BasicCOSCredentials(secretId, secretKey);
	// 2 设置 bucket 的地域
	Region region = new Region(tencentCloudProperties.getRegion());
	ClientConfig clientConfig = new ClientConfig(region);
	// 这里建议设置使用 https 协议
	clientConfig.setHttpProtocol(HttpProtocol.https);
	// 3 生成 cos 客户端。
	COSClient cosClient = new COSClient(cred, clientConfig);
	return cosClient;
}

@Override
public String getImagerUrl(String path) {
	if(!StringUtils.hasText(path)){
		return "";
	}
	COSClient cosClient = getCosClient();
	GeneratePresignedUrlRequest request =
			new GeneratePresignedUrlRequest(tencentCloudProperties.getBucketPrivate(),
					path,
					HttpMethodName.GET);
	// 设置临时URL有效期
	DateTime dateTime = new DateTime().plusMinutes(15);
	request.setExpiration(dateTime.toDate());
	// 调用方法获取
	URL url = cosClient.generatePresignedUrl(request);
	cosClient.shutdown();
	return url.toString();
}

@Slf4j
@Tag(name = "腾讯云识别接口管理")
@RestController
@RequestMapping(value="/ocr")
@SuppressWarnings({"unchecked", "rawtypes"})
public class OcrController {

    @Autowired
    private OcrService ocrService;

    @Operation(summary = "身份证识别")
    @PostMapping("/idCardOcr")
    public Result<IdCardOcrVo> idCardOcr(@RequestPart("file") MultipartFile file) {
        IdCardOcrVo idCardOcrVo = ocrService.idCardOcr(file);
        return Result.ok(idCardOcrVo);
    }

	@Operation(summary = "驾驶证识别")  
	@PostMapping("/driverLicenseOcr")  
	public Result<DriverLicenseOcrVo> driverLicenseOcr(@RequestPart("file") MultipartFile file) {  
	    DriverLicenseOcrVo driverLicenseOcrVo = ocrService.driverLicenseOcr(file);  
	    return Result.ok(driverLicenseOcrVo);  
	}
}

<dependency>  
    <groupId>com.tencentcloudapi</groupId>  
    <artifactId>tencentcloud-sdk-java</artifactId>  
    <version>${tencentcloud.version}</version>  
</dependency>

@Slf4j
@Service
@SuppressWarnings({"unchecked", "rawtypes"})
public class OcrServiceImpl implements OcrService {

    @Autowired
    private TencentCloudProperties tencentCloudProperties;

    @Autowired
    private CosService cosService;

    // 身份证识别
    @Override
    public IdCardOcrVo idCardOcr(MultipartFile file) {
        try{
            // file转换成base64
            byte[] base64 = Base64.encodeBase64(file.getBytes());
            String fileBase64 = new String(base64);
            // 实例化一个认证对象，入参需要传入腾讯云账户 SecretId 和 SecretKey，此处还需注意密钥对的保密
            Credential cred = new Credential(tencentCloudProperties.getSecretId(),
                    tencentCloudProperties.getSecretKey());
            // 实例化一个http选项，可选的，没有特殊需求可以跳过
            HttpProfile httpProfile = new HttpProfile();
            httpProfile.setEndpoint("ocr.tencentcloudapi.com");
            // 实例化一个client选项，可选的，没有特殊需求可以跳过
            ClientProfile clientProfile = new ClientProfile();
            clientProfile.setHttpProfile(httpProfile);
            // 实例化要请求产品的client对象,clientProfile是可选的
            OcrClient client = new OcrClient(cred,tencentCloudProperties.getRegion(), clientProfile);
            // 实例化一个请求对象,每个接口都会对应一个request对象
            IDCardOCRRequest req = new IDCardOCRRequest();
            //设置文件
            req.setImageBase64(fileBase64);

            // 返回的resp是一个IDCardOCRResponse的实例，与请求对象对应
            IDCardOCRResponse resp = client.IDCardOCR(req);

            //转换为IdCardOcrVo对象
            IdCardOcrVo idCardOcrVo = new IdCardOcrVo();
            if (StringUtils.hasText(resp.getName())) {
                //身份证正面
                idCardOcrVo.setName(resp.getName());
                idCardOcrVo.setGender("男".equals(resp.getSex()) ? "1" : "2");
                idCardOcrVo.setBirthday(DateTimeFormat.forPattern("yyyy/MM/dd").parseDateTime(resp.getBirth()).toDate());
                idCardOcrVo.setIdcardNo(resp.getIdNum());
                idCardOcrVo.setIdcardAddress(resp.getAddress());

                //上传身份证正面图片到腾讯云cos
                CosUploadVo cosUploadVo = cosService.upload(file, "idCard");
                idCardOcrVo.setIdcardFrontUrl(cosUploadVo.getUrl());
                idCardOcrVo.setIdcardFrontShowUrl(cosUploadVo.getShowUrl());
            } else {
                //身份证反面
                //证件有效期："2010.07.21-2020.07.21"
                String idcardExpireString = resp.getValidDate().split("-")[1];
                idCardOcrVo.setIdcardExpire(DateTimeFormat.forPattern("yyyy.MM.dd").parseDateTime(idcardExpireString).toDate());
                //上传身份证反面图片到腾讯云cos
                CosUploadVo cosUploadVo = cosService.upload(file, "idCard");
                idCardOcrVo.setIdcardBackUrl(cosUploadVo.getUrl());
                idCardOcrVo.setIdcardBackShowUrl(cosUploadVo.getShowUrl());
            }
            return idCardOcrVo;
        } catch (Exception e) {
            throw new GuiguException(ResultCodeEnum.DATA_ERROR);
        }
    }

	//驾驶证识别  
	@Override  
	public DriverLicenseOcrVo driverLicenseOcr(MultipartFile file) {  
	    try{  
	        //图片转换base64格式字符串  
	        byte[] base64 = Base64.encodeBase64(file.getBytes());  
	        String fileBase64 = new String(base64);  
	  
	        // 实例化一个认证对象，入参需要传入腾讯云账户 SecretId 和 SecretKey，此处还需注意密钥对的保密  
	        Credential cred = new Credential(tencentCloudProperties.getSecretId(),  
	                tencentCloudProperties.getSecretKey());  
	        // 实例化一个http选项，可选的，没有特殊需求可以跳过  
	        HttpProfile httpProfile = new HttpProfile();  
	        httpProfile.setEndpoint("ocr.tencentcloudapi.com");  
	        // 实例化一个client选项，可选的，没有特殊需求可以跳过  
	        ClientProfile clientProfile = new ClientProfile();  
	        clientProfile.setHttpProfile(httpProfile);  
	        // 实例化要请求产品的client对象,clientProfile是可选的  
	        OcrClient client = new OcrClient(cred, tencentCloudProperties.getRegion(),  
	                clientProfile);  
	        // 实例化一个请求对象,每个接口都会对应一个request对象  
	        DriverLicenseOCRRequest req = new DriverLicenseOCRRequest();  
	        req.setImageBase64(fileBase64);  
	  
	        // 返回的resp是一个DriverLicenseOCRResponse的实例，与请求对象对应  
	        DriverLicenseOCRResponse resp = client.DriverLicenseOCR(req);  
	  
	        //封装到vo对象里面  
	        DriverLicenseOcrVo driverLicenseOcrVo = new DriverLicenseOcrVo();  
	        if (StringUtils.hasText(resp.getName())) {  
	            //驾驶证正面  
	            //驾驶证名称要与身份证名称一致  
	            driverLicenseOcrVo.setName(resp.getName());  
	            driverLicenseOcrVo.setDriverLicenseClazz(resp.getClass_());  
	            driverLicenseOcrVo.setDriverLicenseNo(resp.getCardCode());  
	            driverLicenseOcrVo.setDriverLicenseIssueDate(DateTimeFormat.forPattern("yyyy-MM-dd").parseDateTime(resp.getDateOfFirstIssue()).toDate());  
	            driverLicenseOcrVo.setDriverLicenseExpire(DateTimeFormat.forPattern("yyyy-MM-dd").parseDateTime(resp.getEndDate()).toDate());  
	  
	            //上传驾驶证反面图片到腾讯云cos  
	            CosUploadVo cosUploadVo = cosService.upload(file, "driverLicense");  
	            driverLicenseOcrVo.setDriverLicenseFrontUrl(cosUploadVo.getUrl());  
	            driverLicenseOcrVo.setDriverLicenseFrontShowUrl(cosUploadVo.getShowUrl());  
	        } else {  
	            //驾驶证反面  
	            //上传驾驶证反面图片到腾讯云cos  
	            CosUploadVo cosUploadVo =  cosService.upload(file, "driverLicense");  
	            driverLicenseOcrVo.setDriverLicenseBackUrl(cosUploadVo.getUrl());  
	            driverLicenseOcrVo.setDriverLicenseBackShowUrl(cosUploadVo.getShowUrl());  
	        }  
	  
	        return driverLicenseOcrVo;  
	    } catch (Exception e) {  
	        e.printStackTrace();  
	        throw new GuiguException(ResultCodeEnum.DATA_ERROR);  
	    }  
	}
}

@FeignClient(value = "service-driver")  
public interface OcrFeignClient {  
  
    @PostMapping(value = "/ocr/idCardOcr", consumes = MediaType.MULTIPART_FORM_DATA_VALUE)  
    Result<IdCardOcrVo> idCardOcr(@RequestPart("file") MultipartFile file);  
  
    @PostMapping(value = "/ocr/driverLicenseOcr", consumes = MediaType.MULTIPART_FORM_DATA_VALUE)  
    Result<DriverLicenseOcrVo> driverLicenseOcr(@RequestPart("file") MultipartFile file);  
}

@Slf4j  
@Tag(name = "腾讯云识别接口管理")  
@RestController  
@RequestMapping(value="/ocr")  
@SuppressWarnings({"unchecked", "rawtypes"})  
public class OcrController {  
  
    @Autowired  
    private OcrService ocrService;  
  
    @Operation(summary = "身份证识别")  
    @LoginDetection  
    @PostMapping("/idCardOcr")  
    public Result<IdCardOcrVo> uploadDriverLicenseOcr(@RequestPart("file")MultipartFile file){  
        return Result.ok(ocrService.idCardOcr(file));  
    }  
  
    @Operation(summary = "驾驶证识别")  
    @LoginDetection  
    @PostMapping("/driverLicenseOcr")  
    public Result<DriverLicenseOcrVo> driverLicenseOcr(@RequestPart("file")MultipartFile file){  
        return Result.ok(ocrService.driverLicenseOcr(file));  
    }  
}

@Slf4j  
@Service  
@SuppressWarnings({"unchecked", "rawtypes"})  
public class OcrServiceImpl implements OcrService {  
  
    @Autowired  
    private OcrFeignClient ocrFeignClient;  
  
    // 身份证  
    @Override  
    public IdCardOcrVo idCardOcr(MultipartFile file) {  
        Result<IdCardOcrVo> ocrVoResult = ocrFeignClient.idCardOcr(file);  
        return ocrVoResult.getData();  
    }  
  
    // 驾驶证  
    @Override  
    public DriverLicenseOcrVo driverLicenseOcr(MultipartFile file) {  
        Result<DriverLicenseOcrVo> result = ocrFeignClient.driverLicenseOcr(file);  
        return result.getData();  
    }  
}