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

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

2023-07-11 222
版权
版权声明：
本文内容由阿里云实名注册用户自发贡献，版权归原作者所有，阿里云开发者社区不拥有其著作权，亦不承担相应法律责任。具体规则请查看《 阿里云开发者社区用户服务协议》和 《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容，填写 侵权投诉表单进行举报，一经查实，本社区将立刻删除涉嫌侵权内容。
本文涉及的产品
Redis 开源版，标准版 2GB
推荐场景：
搭建游戏排行榜
云数据库 RDS MySQL，集群系列 2核4GB
推荐场景：
搭建个人博客
RDS MySQL Serverless 基础系列，0.5-2RCU 50GB
推荐场景：
学生管理系统数据库设计 搭建个人博客
简介： 手把手教你云相册项目简易开发 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
中间件
缓存
关键词：
kafka Spring Boot
项目Idea
springboot云数据库 Tair（兼容 Redis）
项目云数据库 Tair（兼容 Redis）
云数据库 Tair（兼容 Redis）MySQL
kkoneone11
目录
相关文章
聚优云惠
|
19天前
|
XML Java 数据格式
SpringBoot入门(8) - 开发中还有哪些常用注解
SpringBoot入门(8) - 开发中还有哪些常用注解
聚优云惠
38 0
武子康
|
2月前
|
消息中间件 分布式计算 NoSQL
大数据-104 Spark Streaming Kafka Offset Scala实现Redis管理Offset并更新
大数据-104 Spark Streaming Kafka Offset Scala实现Redis管理Offset并更新
武子康
42 0
蓝易云
|
19天前
|
NoSQL Java API
springboot项目Redis统计在线用户
通过本文的介绍，您可以在Spring Boot项目中使用Redis实现在线用户统计。通过合理配置Redis和实现用户登录、注销及统计逻辑，您可以高效地管理在线用户。希望本文的详细解释和代码示例能帮助您在实际项目中成功应用这一技术。
蓝易云
27 3
蓝易云
|
21天前
|
消息中间件 NoSQL Java
Spring Boot整合Redis
通过Spring Boot整合Redis，可以显著提升应用的性能和响应速度。在本文中，我们详细介绍了如何配置和使用Redis，包括基本的CRUD操作和具有过期时间的值设置方法。希望本文能帮助你在实际项目中高效地整合和使用Redis。
蓝易云
39 1
东方睿赢
|
2月前
|
缓存 NoSQL Java
Spring Boot与Redis：整合与实战
【10月更文挑战第15天】本文介绍了如何在Spring Boot项目中整合Redis，通过一个电商商品推荐系统的案例，详细展示了从添加依赖、配置连接信息到创建配置类的具体步骤。实战部分演示了如何利用Redis缓存提高系统响应速度，减少数据库访问压力，从而提升用户体验。
东方睿赢
92 2
小Tomkk
|
2月前
|
存储 自然语言处理 关系型数据库
mysql 8.0 日期维度表生成（可运行）
mysql 8.0 日期维度表生成（可运行）
小Tomkk
52 2
明弟有理想
|
2月前
|
JSON NoSQL Java
springBoot:jwt&redis&文件操作&常见请求错误代码&参数注解 (九)
该文档涵盖JWT（JSON Web Token）的组成、依赖、工具类创建及拦截器配置，并介绍了Redis的依赖配置与文件操作相关功能，包括文件上传、下载、删除及批量删除的方法。同时，文档还列举了常见的HTTP请求错误代码及其含义，并详细解释了@RequestParam与@PathVariable等参数注解的区别与用法。
明弟有理想
26 2
java冯坚持
|
2月前
|
NoSQL Java Redis
shiro学习四：使用springboot整合shiro，正常的企业级后端开发shiro认证鉴权流程。使用redis做token的过滤。md5做密码的加密。
这篇文章介绍了如何使用Spring Boot整合Apache Shiro框架进行后端开发，包括认证和授权流程，并使用Redis存储Token以及MD5加密用户密码。
java冯坚持
31 0
shiro学习四：使用springboot整合shiro，正常的企业级后端开发shiro认证鉴权流程。使用redis做token的过滤。md5做密码的加密。
刘大猫.
|
26天前
|
JavaScript NoSQL Java
CC-ADMIN后台简介一个基于 Spring Boot 2.1.3 、SpringBootMybatis plus、JWT、Shiro、Redis、Vue quasar 的前后端分离的后台管理系统
CC-ADMIN后台简介一个基于 Spring Boot 2.1.3 、SpringBootMybatis plus、JWT、Shiro、Redis、Vue quasar 的前后端分离的后台管理系统
刘大猫.
36 0
dasein58
|
1月前
|
JavaScript 前端开发 Java
SpringBoot_web开发-webjars&静态资源映射规则
https://www.91chuli.com/ 举例：jquery前端框架
dasein58
19 0

热门文章

最新文章

  • 1
    解决kafka集群由于默认的__consumer_offsets这个topic的默认的副本数为1而存在的单点故障问题
  • 2
    SQLServer CDC数据通过Kafka connect实时同步至分析型数据库 AnalyticDB For PostgreSQL及OSS
  • 3
    springboot配置kafka生产者和消费者详解
  • 4
    Kafka Producer 异步发送消息居然也会阻塞？
  • 5
    如何查看spark与hadoop、kafka、Scala、flume、hive等兼容版本【适用于任何版本】
  • 6
    kafka集群搭建
  • 7
    ELK+Kafka 企业日志收集平台(一)
  • 8
    flink 手动维护kafka offset
  • 9
    kafka web console安装
  • 10
    Apache Kafka - 灵活控制Kafka消费_动态开启/关闭监听实现
  • 1
    Redis经典问题：数据不一致
    602
  • 2
    Redis经典问题：缓存击穿
    612
  • 3
    Redis数据结构精讲：选择与应用实战指南
    1327
  • 4
    Redis内存分析工具RDR
    1757
  • 5
    Redis基础命令集详解
    48
  • 6
    Mac上轻松几步搞定Docker与Redis安装：从下载安装到容器运行实测全程指南
    914
  • 7
    Redis哨兵&分片集群
    87
  • 8
    Redis多级缓存
    50
  • 9
    Redis持久化&Redis主从
    48
  • 10
    Redis 缓存 一致性
    58

    • 相关课程

    更多
  • Redis入门实战演练
  • SpringBoot快速掌握 - 核心技术
  • SpringBoot快速掌握 - 高级应用
  • 云数据库 Redis 版使用教程
  • Springboot项目云开发快速迁移
  • Redis数据库入门

    • 相关电子书

    更多
  • Redis集群演化的心路历程——从2.x到3.0时代
  • ApsaraDB for Redis——与创客同行
  • 蚂蚁金服高级开发工程师萧恺：IDEA 插件开发入门教程

    • 相关实验场景

    更多
  • MySQL基础-学生管理系统数据库设计
  • 如何快速连接云数据库RDS MySQL
  • MySQL数据库快速部署实践
  • MySQL引擎及架构优化
  • 基于EBS部署高性能的MySQL服务
  • 使用CloudLens采集RDS日志并进行审计分析

    • 推荐镜像

    更多
  • mysql
  • mariadb
  • postgresql
    • 下一篇
    阿里云无影云电脑免费试用，最长可试用3个月