AI 助理
备案控制台
开发者社区 数据库 文章 正文

手把手教你云相册项目简易开发 day1 Kafka+IDEA+Springboot+Redis+MySQL+libvips 简单运行和使用

2023-07-11 216
版权
版权声明：
本文内容由阿里云实名注册用户自发贡献，版权归原作者所有，阿里云开发者社区不拥有其著作权，亦不承担相应法律责任。具体规则请查看《 阿里云开发者社区用户服务协议》和 《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容，填写 侵权投诉表单进行举报，一经查实，本社区将立刻删除涉嫌侵权内容。
本文涉及的产品
RDS MySQL Serverless 基础系列，0.5-2RCU 50GB
推荐场景：
学生管理系统数据库设计 搭建个人博客
Redis 开源版，标准版 2GB
推荐场景：
搭建游戏排行榜
云数据库 RDS MySQL，集群系列 2核4GB
推荐场景：
搭建个人博客
简介： 手把手教你云相册项目简易开发 day1 Kafka+IDEA+Springboot+Redis+MySQL+libvips 简单运行和使用

项目的创建

项目采用的是微服务的架构。先创建一个父项目cloud-photo，然后再在module下创建api、image、users的子项目相关配置：

application.yml。此处如果没有redis的话可以先注释掉，因为后面启动需要mysql连接成功和redis服务启动

spring:
  cloud:
    # nacos config
    nacos:
      discovery:
        username: nacos
        password: nacos
        server-addr: 127.0.0.1:8848
  redis:
    host: 127.0.0.1
    port: 6379
  application:
    name: cloud-photo-api
  datasource:
    url: jdbc:mysql://127.0.0.1:3306/photo?zeroDateTimeBehavior=convertToNull&?useSSL=false&allowMultiQueries=true
    username: root
    password: root
    driver-class-name: com.mysql.jdbc.Driver
  kafka:
    bootstrap-servers: 127.0.0.1:9092
    producer: # producer 生产者
      retries: 0 # 重试次数
      acks: 1 # 应答级别:多少个分区副本备份完成时向生产者发送ack确认(可选0、1、all/-1)
      batch-size: 16384 # 批量大小
      buffer-memory: 33554432 # 生产端缓冲区大小
      key-serializer: org.apache.kafka.common.serialization.StringSerializer
      value-serializer: org.apache.kafka.common.serialization.StringSerializer
    consumer: # consumer消费者
      group-id: javagroup # 默认的消费组ID
      enable-auto-commit: true # 是否自动提交offset
      auto-commit-interval: 100  # 提交offset延时(接收到消息后多久提交offset)
      # earliest:当各分区下有已提交的offset时，从提交的offset开始消费；无提交的offset时，从头开始消费
      # latest:当各分区下有已提交的offset时，从提交的offset开始消费；无提交的offset时，消费新产生的该分区下的数据
      # none:topic各分区都存在已提交的offset时，从offset后开始消费；只要有一个分区不存在已提交的offset，则抛出异常
      auto-offset-reset: latest
      key-deserializer: org.apache.kafka.common.serialization.StringDeserializer
      value-deserializer: org.apache.kafka.common.serialization.StringDeserializer
#服务端口
server:
  port: 9007

pom.xml文件配置

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <groupId>org.example</groupId>
    <artifactId>cloud-photo-3121004041</artifactId>
    <packaging>pom</packaging>
    <version>1.0-SNAPSHOT</version>
    <modules>
        <module>cloud-photo-api</module>
        <module>cloud-photo-image</module>
        <module>cloud-photo-users</module>
    </modules>
    <properties>
        <maven.compiler.source>8</maven.compiler.source>
        <maven.compiler.target>8</maven.compiler.target>
        <mybatisplus.version>3.5.3</mybatisplus.version>
        <spring-boot.version>2.3.12.RELEASE</spring-boot.version>
        <spring-cloud.version>Hoxton.SR12</spring-cloud.version>
        <spring-cloud-alibaba.version>2.2.10-RC1</spring-cloud-alibaba.version>
    </properties>
    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
            <scope>compile</scope>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-actuator</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-test</artifactId>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-test</artifactId>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.13.1</version>
            <scope>test</scope>
        </dependency>
        <!-- kafka-->
        <dependency>
            <groupId>org.springframework.kafka</groupId>
            <artifactId>spring-kafka</artifactId>
        </dependency>
        <!--        redis-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-redis</artifactId>
        </dependency>
        <!--        jedis-->
        <dependency>
            <groupId>redis.clients</groupId>
            <artifactId>jedis</artifactId>
            <version>2.9.0</version>
        </dependency>
        <!--  执行命令 -->
        <dependency>
            <groupId>org.apache.commons</groupId>
            <artifactId>commons-exec</artifactId>
            <version>1.3</version>
        </dependency>
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>5.1.47</version>
        </dependency>
        <dependency>
            <groupId>com.baomidou</groupId>
            <artifactId>mybatis-plus-boot-starter</artifactId>
            <version>3.5.3</version>
        </dependency>
        <dependency>
            <groupId>com.baomidou</groupId>
            <artifactId>mybatis-plus-generator</artifactId>
            <version>3.5.3</version>
        </dependency>
        <dependency>
            <groupId>org.freemarker</groupId>
            <artifactId>freemarker</artifactId>
            <version>2.3.31</version>
        </dependency>
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <version>1.18.20</version>
        </dependency>
    </dependencies>
    <dependencyManagement>
        <dependencies>
            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-dependencies</artifactId>
                <version>${spring-boot.version}</version>
                <type>pom</type>
                <scope>import</scope>
            </dependency>
            <dependency>
                <groupId>org.springframework.cloud</groupId>
                <artifactId>spring-cloud-dependencies</artifactId>
                <version>${spring-cloud.version}</version>
                <type>pom</type>
                <scope>import</scope>
            </dependency>
            <dependency>
                <groupId>com.alibaba.cloud</groupId>
                <artifactId>spring-cloud-alibaba-dependencies</artifactId>
                <version>${spring-cloud-alibaba.version}</version>
                <type>pom</type>
                <scope>import</scope>
            </dependency>
        </dependencies>
    </dependencyManagement>
</project>

MySQL

表的创建

CREATE TABLE `tb_file_audit` (
  `file_audit_id` varchar(64) NOT NULL DEFAULT '',
  `file_name` varchar(128) DEFAULT NULL,
  `md5` varchar(64) DEFAULT NULL,
  `file_size` int(11) DEFAULT NULL,
  `storage_object_id` varchar(64) DEFAULT NULL,
  `audit_status` int(11) DEFAULT NULL,
  `remark` varchar(128) DEFAULT NULL,
  `create_time` timestamp NULL DEFAULT NULL,
  `user_file_id` varchar(64) DEFAULT NULL,
  PRIMARY KEY (`file_audit_id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8 COMMENT='文件审核列表';
CREATE TABLE `tb_file_md5` (
  `file_md5_id` varchar(64) NOT NULL DEFAULT '',
  `md5` varchar(64) DEFAULT NULL COMMENT '文件md5',
  `file_size` int(11) DEFAULT NULL COMMENT '文件大小',
  `storage_object_id` varchar(64) DEFAULT NULL COMMENT '存储id',
  PRIMARY KEY (`file_md5_id`),
  KEY `tb_file_md5_md5_idx` (`md5`,`file_size`) USING BTREE
) ENGINE=InnoDB DEFAULT CHARSET=utf8 COMMENT='文件MD5列表';
CREATE TABLE `tb_file_resize_icon` (
  `file_resize_icon_id` varchar(64) NOT NULL DEFAULT '' COMMENT 'id',
  `storage_object_id` varchar(100) DEFAULT NULL COMMENT '图片存储id',
  `icon_code` varchar(20) DEFAULT NULL COMMENT '图片尺寸(240_240,600_600)',
  `container_id` varchar(20) DEFAULT NULL COMMENT '缩略图存储桶',
  `object_id` varchar(64) DEFAULT NULL COMMENT '缩略图存储id',
  PRIMARY KEY (`file_resize_icon_id`),
  KEY `tb_file_resize_icon_storage_object_id_idx` (`storage_object_id`,`icon_code`) USING BTREE
) ENGINE=InnoDB DEFAULT CHARSET=utf8 COMMENT='图片缩略图';
CREATE TABLE `tb_media_info` (
  `media_info_id` varchar(64) DEFAULT NULL,
  `width` int(11) DEFAULT NULL,
  `height` int(11) DEFAULT NULL,
  `shooting_time` varchar(30) DEFAULT NULL COMMENT '拍摄时间',
  `gps_latitude` int(11) DEFAULT NULL,
  `gps_longitude` int(11) DEFAULT NULL,
  `storage_object_id` varchar(64) DEFAULT NULL
) ENGINE=InnoDB DEFAULT CHARSET=utf8 COMMENT='文件媒体信息';
CREATE TABLE `tb_storage_object` (
  `storage_object_id` varchar(64) NOT NULL,
  `storage_provider` varchar(10) DEFAULT NULL COMMENT '存储池供应商',
  `container_id` varchar(20) DEFAULT NULL COMMENT '桶ID',
  `object_id` varchar(100) DEFAULT NULL COMMENT '存储池文件id',
  `md5` varchar(64) DEFAULT NULL COMMENT '文件md5',
  `object_size` varchar(64) DEFAULT NULL COMMENT '文件大小',
  PRIMARY KEY (`storage_object_id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8 COMMENT='资源池文件存储信息';
CREATE TABLE `tb_user` (
  `user_id` varchar(10) NOT NULL COMMENT '用户Id',
  `user_name` varchar(100) DEFAULT NULL COMMENT '用户名',
  `department` varchar(50) DEFAULT NULL COMMENT '用户所属地',
  `phone` varchar(20) DEFAULT NULL COMMENT '用户手机号',
  `password` varchar(100) DEFAULT NULL COMMENT '用户密码',
  `create_time` datetime DEFAULT NULL COMMENT '用户创建时间',
  `update_time` datetime DEFAULT NULL COMMENT '用户最后登录时间',
  `login_count` int(11) DEFAULT NULL COMMENT '用户登录次数',
  `role` varchar(20) DEFAULT NULL COMMENT '用户角色',
  `birth` date DEFAULT NULL COMMENT '用户出生年月日',
  `new_column` int(11) DEFAULT NULL,
  PRIMARY KEY (`user_id`),
  UNIQUE KEY `tb_user_user_id_uindex` (`user_id`),
  KEY `actable_idx_idx_user_name` (`user_name`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8;
CREATE TABLE `tb_user_file` (
  `user_file_id` varchar(64) NOT NULL DEFAULT '',
  `user_id` varchar(64) DEFAULT NULL COMMENT '用户id',
  `file_name` varchar(200) DEFAULT NULL COMMENT '文件名',
  `parent_id` varchar(64) DEFAULT NULL COMMENT '父目录id',
  `file_size` bigint(20) DEFAULT NULL COMMENT '文件大小',
  `file_status` varchar(2) DEFAULT NULL COMMENT '文件状态(1 正常 2删除)',
  `file_type` varchar(10) DEFAULT NULL COMMENT '文件类型',
  `is_folder` varchar(2) DEFAULT NULL COMMENT '是否是目录',
  `create_time` timestamp NULL DEFAULT NULL COMMENT '创建时间',
  `modify_time` timestamp NULL DEFAULT NULL COMMENT '修改时间',
  `storage_object_id` varchar(64) DEFAULT NULL COMMENT '存储id',
  `category` int(11) DEFAULT NULL COMMENT '文件分类',
  `audit_status` int(11) DEFAULT NULL COMMENT '审核状态(00待审核 01 审核通过 02 审核不通过)',
  PRIMARY KEY (`user_file_id`),
  KEY `tb_user_file_user_id_idx` (`user_id`,`file_status`,`create_time`) USING BTREE
) ENGINE=InnoDB DEFAULT CHARSET=utf8;

Kafka

启动Kafka可以先看这篇文章：Kafka的保姆级简易安装启动、关闭注意事项、简单使用_kkoneone11的博客-CSDN博客


本机操作Kafka

新建一个cmd窗口进行命令操作：


1.新建一个名为file-image-topic的topic


语句解析：这条语句是用于创建一个名为"file-image-topic"的Kafka主题。它使用了kafka-topics.bat命令，并指定了以下参数：


--bootstrap-server：指定Kafka集群的地址和端口，这里是localhost:9092。

--replication-factor：指定主题的副本因子，这里是1，表示每个分区只有一个副本。

--partitions：指定主题的分区数，这里是3，表示主题被分为3个分区。

--topic：指定要创建的主题的名称，这里是"file-image-topic"。

kafka-topics.bat -create --bootstrap-server localhost:9092 --replication-factor 1 --partitions 3 --topic file-image-topic

2.查看已经存在的topic

kafka-topics.bat --list --bootstrap-server localhost:9092

3.写消息：往file-image-topic中写消息

kafka-console-producer.bat --broker-list localhost:9092 --topic file-image-topic

4.读消息

kafka-console-consumer.bat --bootstrap-server localhost:9092 --topic file-image-topic --from-beginning


Springboot项目中使用Kafka

1.创建一个KafkaServiceImpl类2.KafkaTemplate


项目中通过KafkaTemplate<?,String> kafkaTemplate来对kafka进行操作，其中读消息用到send方法，读取信息就先通过@KafkaListener的监听器指定topic然后再通过ConsumerRecord<String,String>对里面的信息进行读取

package com.cloud.photo.api.utils;
import org.apache.kafka.clients.consumer.ConsumerRecord;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.kafka.annotation.KafkaListener;
import org.springframework.kafka.core.KafkaTemplate;
import org.springframework.stereotype.Service;
/**
 * @Author：kkoneone11
 * @name：KafkaServiceImpl
 * @Date：2023/7/9 14:20
 */
@Service
public class KafkaServiceImpl {
    private static final String FILE_IMAGE_TOPIC = "file-image-topic";
    @Autowired
    private KafkaTemplate<?,String> kafkaTemplate;
    /**
     * 发送kafka信息
     */
    public void send(String message){
        kafkaTemplate.send(FILE_IMAGE_TOPIC,message);
        System.out.println("send message :"+message);
    }
    /**
     * 消费FILE_IMAGE_TOPIC中的消息
     */
    @KafkaListener(topics = {"file-image-topic"})
    public void onMessage(ConsumerRecord<String,String> record){
        System.out.println("onMessage,key="+record.key()+",value="+record.value());
    }
}

3.测试写入消息方法

要保证pom里已经有了junit测试框架
先在test包下创建一个KafkaSeriveTest类
要注意在类的头顶还有@SpringBootTest @RunWith(SpringRunner.class)两个备注


然后在测试类中通过@Autowired让Springboot管理要引入要调用的类，因为这个类已经通过@Service让Springboot进行管理了所以直接@Autowired。而方法就得在头上加@Test

package com.cloud.photo.api.util;
import com.cloud.photo.api.utils.KafkaServiceImpl;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.context.junit4.SpringRunner;
/**
 * @Author：kkoneone11
 * @name：KafkaSeriveTest
 * @Date：2023/7/9 14:44
 */
@SpringBootTest
@RunWith(SpringRunner.class)
public class KafkaSeriveTest {
    @Autowired
    private KafkaServiceImpl kafkaService;
    @Test
    public void send(){
        kafkaService.send("666");
    }
}

然后运行test类看到以下信息就说明发送成功了，可以到Kafka中进行查看是否有该消息

4.测试读取方法

因为消费kafka消息是通过kafka自带的Listener来进行的，所以运行这个方法是要通过一个启动类ApiAPP来进行测试方法

package com.cloud.photo.api;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
/**
 * @Author：kkoneone11
 * @name：ApiApp
 * @Date：2023/7/9 10:03
 */
@SpringBootApplication
public class ApiApp {
    public static void main(String[] args) {
        SpringApplication.run(ApiApp.class,args);
    }
}

此时ApiApp主方法就是一直在启动的，然后这时候需要我们再启动一下test方法，发送一条信息到topic上（因为上一次已经把666那条信息给消费了）。

发送的新信息

此时可以看到ApiApp控制台上消息被立刻消费了，即已经同步运行了Listener监听器的办法消费了信息
Redis

redis在此处的作用是中间件的缓存，常用到ValueOperations中对值的操作，通过其中的set方法存储一个键值对，get方法根据key获取对应的value值


1.先创建一个RedisServiceImpl类


同样交给对Redis的操作通常是通过RedisTemplate，而我们这用的是StringRedisTemplate，是RedisTemplate的子类。因为Redis可操作的对象类型有很多

package com.cloud.photo.api.utils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.data.redis.core.ValueOperations;
import org.springframework.stereotype.Service;
import javax.annotation.Resource;
/**
 * @Author：kkoneone11
 * @name：RedisServiceImpl
 * @Date：2023/7/9 15:30
 */
@Service
public class RedisServiceImpl {
    @Autowired
    private StringRedisTemplate stringRedisTemplate;
    private static final String USER_CACHE_PRE = "u_c_";
    /**
     * 设置缓存
     */
    public void setUser2Cache(Long userId,String username){
        //加一个前缀方便数据的对应
        String cacheKey = USER_CACHE_PRE+userId;
        ValueOperations<String,String> valueOps = stringRedisTemplate.opsForValue();
        valueOps.set(cacheKey,username);
    }
    /**
     * 缓存读取
     */
    public String getUserCache(Long useId){
        String cacheKey = USER_CACHE_PRE + useId;
        ValueOperations<String,String> valueOps = stringRedisTemplate.opsForValue();
        return valueOps.get(cacheKey);
    }
}

2.测试，创建RedisSeriveImplTest类

package com.cloud.photo.api.utils;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.context.junit4.SpringRunner;
/**
 * @Author：kkoneone11
 * @name：RedisSeriveImplTest
 * @Date：2023/7/9 16:10
 */
@SpringBootTest
@RunWith(SpringRunner.class)
public class RedisSeriveImplTest {
    @Autowired
    private RedisServiceImpl redisService;
    @Test
    public void setUser2Cache(){
        redisService.setUser2Cache(888888l,"kkoneone11");
    }
    /**
     *获取一万次名字所需要用的时间
     */
    @Test
    public void getUserCache(){
        long beginTime = System.currentTimeMillis();
        String userName = "";
        for (int i = 0; i <= 10000; i++) {
            userName = redisService.getUserCache(888888L);
        }
        System.out.println("getUserCache=" + userName + ",get 10000 cost:" + (System.currentTimeMillis() - beginTime) + "毫秒");
    }
}

执行set方法后可以看到redis里已经有了对应的键值
执行get方法后可以看到成功执行

mybatis-plus-genator

1.当数据库中建好表，IDEA连接成功后，在cloud-photo-users子项目中创建一个 CodeGenerator类

package com.cloud.photo.users;
import com.baomidou.mybatisplus.generator.FastAutoGenerator;
import com.baomidou.mybatisplus.generator.config.OutputFile;
import com.baomidou.mybatisplus.generator.engine.FreemarkerTemplateEngine;
import java.util.Collections;
import java.util.HashMap;
import java.util.Map;
/**
 * @Author：kkoneone11
 * @name：CodeGenerator
 * @Date：2023/7/9 16:53
 */
public class CodeGenerator {
    public static void main(String[] args) {
        //此处记得要修改自己对应的账号密码。和下方修改输出的制定目录
        String url = "jdbc:mysql://localhost:3306/photo?setUnicode=true&characterEncoding=utf8";
        String username = "root";
        String password = "1234";
        FastAutoGenerator.create(url, username, password)
                .globalConfig(builder -> {
                    builder.author("ltao") // 设置作者
                            // .enableSwagger() // 开启 swagger 模式
                            .fileOverride() // 覆盖已生成文件
                            .disableOpenDir() //禁止打开输出目录
                            .outputDir("D:\\cloud\\cloud-photo\\cloud-photo-users" + "/src/main/java"); // 指定输出目录
                })
                .packageConfig(builder -> {
                    builder.parent("com.cloud.photo") // 设置父包名
                            .moduleName("users") // 设置父包模块名，按照自己的需求修改
                            .entity("entity") //设置entity包名
                            //  .other("model.dto") // 如要设计其他设置dto包名
                            .pathInfo(Collections.singletonMap(OutputFile.xml, "D:/peixun/cloud-photo-g/cloud-photo-user"
                                    + "/src/main/java/com/cloud/photo/user/mapper")); // 设置mapperXml生成路径
                })
                .injectionConfig(consumer -> {
                    Map<String, String> customFile = new HashMap<>();
                    // customFile.put("DTO.java", "/templates/entityDTO.java.ftl");
                    consumer.customFile(customFile);
                })
                .strategyConfig(builder -> {
                    builder.addInclude("tb_user") // 设置需要生成的表名
                            .addTablePrefix("tb_"); // 设置过滤表前缀
                })
                .templateEngine(new FreemarkerTemplateEngine()) // 使用Freemarker引擎模板，默认的是Velocity引擎模板
                .execute();
    }
}

2.然后再创建一个启动Main类用来启动CodeGenerator方法
此处不同的是需要有@MapperScan用来扫描Mapper类

package com.cloud.photo.users;
import org.mybatis.spring.annotation.MapperScan;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
/**
 * @Author：kkoneone11
 * @name：Main
 * @Date：2023/7/9 17:10
 */
@SpringBootApplication
@MapperScan(basePackages = {"com.cloud.photo.*"})
public class Main {
    public static void main(String[] args) {
        SpringApplication.run(Main.class,args);
    }
}

3.然后运行Main方法，成功后显示


MySQL的操作

进行测试

调用getOne方法的时候要先在UserServiceImpl中实现getUserInfoById方法

package com.cloud.photo.users.service.impl;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.cloud.photo.users.entity.User;
import com.cloud.photo.users.mapper.UserMapper;
import com.cloud.photo.users.service.IUserService;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
/**
 * <p>
 *  服务实现类
 * </p>
 *
 * @author ltao
 * @since 2023-07-09
 */
@Service
public class UserServiceImpl extends ServiceImpl<UserMapper, User> implements IUserService {
    public User getUserInfoById(Long userId){
        QueryWrapper queryWrapper = new QueryWrapper<User>();
        queryWrapper.eq("USER_ID",userId);
        return this.getOne(queryWrapper);
    }
}

各个方法执行成功后：

libvips

下载地址：https://github.com/libvips/build-win64-mxe/releases/tag/v8.14.0

下载好libvips后回到cloud-photo-api子项目在下方新建一个VipsUtil类

package com.cloud.photo.api.utils;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.exec.CommandLine;
import org.apache.commons.exec.DefaultExecutor;
import org.apache.commons.exec.PumpStreamHandler;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
@Slf4j
public class VipsUtil {
    //根据实际情况更改
    static String windowsCommand = "D:/software/vips-dev-8.14/bin/vipsthumbnail.exe";
    static String linuxCommand = "/usr/local/bin/vipsthumbnail";
    /**
     *
     * @param srcPath
     * @param desPath
     * @param tarWidth
     * @param tarHight
     * @param quality
     * @return
     */
    public static Boolean thumbnail(String srcPath, String desPath, int tarWidth , int tarHight, String quality) {
        String size_param = "";
        //原图片宽高均小于目前宽高，则直接用原图宽高
        //获取图片宽高
        size_param = tarWidth + "x" + tarHight;
        ByteArrayOutputStream stdout = new ByteArrayOutputStream();
        PumpStreamHandler psh = new PumpStreamHandler(stdout);
        log.info("thumbnail() prepare tools info ");
        //加入参数-t表示自动旋转
        String command = "";
        if (desPath.endsWith(".png")) {
            command = String.format("%s -t %s -s %s -o %s[Q=%s,strip]",windowsCommand, srcPath, size_param, desPath, quality);
        }else {
            command = String.format("%s -t %s -s %s -o %s[Q=%s,optimize_coding,strip]",windowsCommand, srcPath, size_param, desPath, quality);
        }
        CommandLine cl = CommandLine.parse(command);
        log.info("thumbnail() command = " + command);
        DefaultExecutor exec = new DefaultExecutor();
        exec.setStreamHandler(psh);
        try {
            System.out.println(command);
            exec.execute(cl);
        } catch (IOException e) {
            log.warn("thumbnail() exec command failed!");
        }
        return true;
    }
    public  static  void main(String[] args){
        //根据实际情况更改
        String srcPath = "D:/Cloud_images/img/123.jpg";
        String desPath = "D:/Cloud_images/img/output/123_600.jpg";
        int tarWidth = 600;
        int tarHight = 600;
        String quality ="100";
        thumbnail(srcPath, desPath, tarWidth , tarHight,  quality);
    }
}

启动后看output文件夹已经成功有照片

文章标签：
云消息队列 Kafka 版
云数据库 Tair（兼容 Redis）
云数据库 RDS MySQL 版
Java
微服务
消息中间件
关系型数据库
NoSQL
MySQL
Redis
Kafka
中间件
缓存
关键词：
项目Idea
springboot云数据库 Tair（兼容 Redis）
项目云数据库 Tair（兼容 Redis）
云数据库 Tair（兼容 Redis）MySQL
redis云数据库 RDS MySQL 版
kkoneone11
目录
相关文章
聚优云惠
|
7天前
|
XML Java 数据格式
SpringBoot入门(8) - 开发中还有哪些常用注解
SpringBoot入门(8) - 开发中还有哪些常用注解
聚优云惠
24 0
刘大猫.
|
8天前
|
分布式计算 关系型数据库 MySQL
SpringBoot项目中mysql字段映射使用JSONObject和JSONArray类型
SpringBoot项目中mysql字段映射使用JSONObject和JSONArray类型 图像处理 光通信 分布式计算 算法语言 信息技术 计算机应用
刘大猫.
30 8
龙大吉
|
10天前
|
Dubbo Java 应用服务中间件
深入探讨了“dubbo+nacos+springboot3的native打包成功后运行出现异常”的原因及解决方案
本文深入探讨了“dubbo+nacos+springboot3的native打包成功后运行出现异常”的原因及解决方案。通过检查GraalVM版本兼容性、配置反射列表、使用代理类、检查配置文件、禁用不支持的功能、查看日志文件、使用GraalVM诊断工具和调整GraalVM配置等步骤，帮助开发者快速定位并解决问题，确保服务的正常运行。
龙大吉
25 1
小Tomkk
|
29天前
|
存储 自然语言处理 关系型数据库
mysql 8.0 日期维度表生成（可运行）
mysql 8.0 日期维度表生成（可运行）
小Tomkk
42 2
java冯坚持
|
1月前
|
Java 关系型数据库 MySQL
springboot学习五：springboot整合Mybatis 连接 mysql数据库
这篇文章是关于如何使用Spring Boot整合MyBatis来连接MySQL数据库，并进行基本的增删改查操作的教程。
java冯坚持
64 0
springboot学习五：springboot整合Mybatis 连接 mysql数据库
java冯坚持
|
1月前
|
Java 关系型数据库 MySQL
springboot学习四：springboot链接mysql数据库，使用JdbcTemplate 操作mysql
这篇文章是关于如何使用Spring Boot框架通过JdbcTemplate操作MySQL数据库的教程。
java冯坚持
24 0
springboot学习四：springboot链接mysql数据库，使用JdbcTemplate 操作mysql
java冯坚持
|
1月前
|
Java Maven Spring
springboot学习一：idea社区版本创建springboot项目的三种方式（第三种为主）
这篇文章介绍了在IntelliJ IDEA社区版中创建Spring Boot项目的三种方法，特别强调了第三种方法的详细步骤。
java冯坚持
273 0
springboot学习一：idea社区版本创建springboot项目的三种方式（第三种为主）
java冯坚持
|
1月前
|
NoSQL Java Redis
shiro学习四：使用springboot整合shiro，正常的企业级后端开发shiro认证鉴权流程。使用redis做token的过滤。md5做密码的加密。
这篇文章介绍了如何使用Spring Boot整合Apache Shiro框架进行后端开发，包括认证和授权流程，并使用Redis存储Token以及MD5加密用户密码。
java冯坚持
26 0
shiro学习四：使用springboot整合shiro，正常的企业级后端开发shiro认证鉴权流程。使用redis做token的过滤。md5做密码的加密。
dasein58
|
18天前
|
JavaScript 前端开发 Java
SpringBoot_web开发-webjars&静态资源映射规则
https://www.91chuli.com/ 举例：jquery前端框架
dasein58
15 0
刘大猫.
|
18天前
|
关系型数据库 MySQL Java
SpringBoot项目中mysql字段映射使用JSONObject和JSONArray类型
SpringBoot项目中mysql字段映射使用JSONObject和JSONArray类型
刘大猫.
22 0

热门文章

最新文章

  • 1
    解决kafka集群由于默认的__consumer_offsets这个topic的默认的副本数为1而存在的单点故障问题
  • 2
    SQLServer CDC数据通过Kafka connect实时同步至分析型数据库 AnalyticDB For PostgreSQL及OSS
  • 3
    springboot配置kafka生产者和消费者详解
  • 4
    阿里云Kafka幂等生产者与事务生产者
  • 5
    Apache Kafka开发入门指南
  • 6
    kafka集群搭建
  • 7
    Kafka Producer 异步发送消息居然也会阻塞？
  • 8
    ELK+Kafka 企业日志收集平台(一)
  • 9
    kafka web console安装
  • 10
    如何查看spark与hadoop、kafka、Scala、flume、hive等兼容版本【适用于任何版本】
  • 1
    【JAVA进阶篇教学】第八篇：Java链接MySql数据库异常
    232
  • 2
    【JAVA基础篇教学】第十六篇：Java连接和操作MySQL数据库
    307
  • 3
    java mysql druid mybatis-plus里使用多表删除出错的一种处理方式
    88
  • 4
    MySQL免编译安装和用户管理（转）
    31
  • 5
    MySQL 计算时间差分钟
    104
  • 6
    MySQL连接的原理⭐️4种优化连接的手段性能提升240%🚀
    126
  • 7
    MySQL是怎样存储数据的？
    68
  • 8
    MySQL高可用架构探秘：主从复制剖析、切换策略、延迟优化与架构选型
    101
  • 9
    “时光机”与“多维视界”⭐️MySQL中原子性与隔离性的科幻大片
    66
  • 10
    MySQL持久化不为人知的一面⭐️卡顿现象的根源与对策
    69

    • 相关课程

    更多
  • 大数据实战项目：反爬虫系统（Lua+Spark+Redis+Hadoop框架搭建）第二阶段
  • 大数据实战项目 - 反爬虫系统（Lua+Spark+Redis+Hadoop框架搭建）第六阶段
  • Redis入门实战演练
  • 云数据库 Redis 版使用教程
  • 分布式消息系统 Kafka 快速入门
  • Redis数据库入门

    • 相关电子书

    更多
  • Java Spring Boot开发实战系列课程【第16讲】：Spring Boot 2.0 实战Apache Kafka百万级高并发消息中间件与原理解析
  • MaxCompute技术公开课第四季 之 如何将Kafka数据同步至MaxCompute
  • 消息队列kafka介绍

    • 相关实验场景

    更多
  • 从零搭建Spring Boot的Hello World
  • 基于Redis实现在线游戏积分排行榜
  • MongoDB数据库入门
  • 基于 IntelliJ IDEA 插件部署微服务应用
  • 如何开通MySQL的专属集群
  • 如何开通Redis的专属集群

    • 推荐镜像

    更多
  • mysql
  • mariadb
  • postgresql
    • 下一篇
    阿里云OSS设置跨域访问