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

本文涉及的产品
RDS MySQL Serverless 基础系列,0.5-2RCU 50GB
云数据库 Redis 版,社区版 2GB
推荐场景:
搭建游戏排行榜
RDS MySQL Serverless 高可用系列,价值2615元额度,1个月
简介: 手把手教你云相册项目简易开发 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文件夹已经成功有照片

目录
相关文章
|
2天前
|
Oracle Java 关系型数据库
实时计算 Flink版操作报错合集之本地打成jar包,运行报错,idea运行不报错,是什么导致的
在使用实时计算Flink版过程中,可能会遇到各种错误,了解这些错误的原因及解决方法对于高效排错至关重要。针对具体问题,查看Flink的日志是关键,它们通常会提供更详细的错误信息和堆栈跟踪,有助于定位问题。此外,Flink社区文档和官方论坛也是寻求帮助的好去处。以下是一些常见的操作报错及其可能的原因与解决策略。
23 6
|
5天前
|
Java 关系型数据库 MySQL
【MySQL × SpringBoot 突发奇想】全面实现流程 · xlsx文件,Excel表格导入数据库的接口(下)
【MySQL × SpringBoot 突发奇想】全面实现流程 · xlsx文件,Excel表格导入数据库的接口
43 0
|
5天前
|
Java 关系型数据库 MySQL
【MySQL × SpringBoot 突发奇想】全面实现流程 · xlsx文件,Excel表格导入数据库的接口(上)
【MySQL × SpringBoot 突发奇想】全面实现流程 · xlsx文件,Excel表格导入数据库的接口
47 0
|
1天前
|
监控 NoSQL Java
java云MES 系统源码Java+ springboot+ mysql 一款基于云计算技术的企业级生产管理系统
MES系统是生产企业对制造执行系统实施的重点在智能制造执行管理领域,而MES系统特点中的可伸缩、信息精确、开放、承接、安全等也传递出:MES在此管理领域中无可替代的“王者之尊”。MES制造执行系统特点集可伸缩性、精确性、开放性、承接性、经济性与安全性于一体,帮助企业解决生产中遇到的实际问题,降低运营成本,快速适应企业不断的制造执行管理需求,使得企业已有基础设施与一切可用资源实现高度集成,提升企业投资的有效性。
26 5
|
2天前
|
Oracle Java 关系型数据库
实时计算 Flink版操作报错合集之本地打成jar包,运行报错,idea运行不报错,是什么导致的
在使用实时计算Flink版过程中,可能会遇到各种错误,了解这些错误的原因及解决方法对于高效排错至关重要。针对具体问题,查看Flink的日志是关键,它们通常会提供更详细的错误信息和堆栈跟踪,有助于定位问题。此外,Flink社区文档和官方论坛也是寻求帮助的好去处。以下是一些常见的操作报错及其可能的原因与解决策略。
12 0
|
3天前
|
监控 安全 NoSQL
采用java+springboot+vue.js+uniapp开发的一整套云MES系统源码 MES制造管理系统源码
MES系统是一套具备实时管理能力,建立一个全面的、集成的、稳定的制造物流质量控制体系;对生产线、工艺、人员、品质、效率等多方位的监控、分析、改进,满足精细化、透明化、自动化、实时化、数据化、一体化管理,实现企业柔性化制造管理。
23 3
|
3天前
|
消息中间件 关系型数据库 MySQL
MySQL 到 Kafka 实时数据同步实操分享(1),字节面试官职级
MySQL 到 Kafka 实时数据同步实操分享(1),字节面试官职级
|
4天前
|
JavaScript Java 关系型数据库
基于springboot+vue+Mysql的交流互动系统
简化操作,便于维护和使用。
16 2
|
5天前
|
前端开发 关系型数据库 MySQL
SpringBoot-----从前端更新数据到MySql数据库
SpringBoot-----从前端更新数据到MySql数据库
14 1
|
5天前
|
前端开发 关系型数据库 MySQL
【MySQL × SpringBoot 突发奇想】全面实现流程 · 数据库导出Excel表格文件的接口
【MySQL × SpringBoot 突发奇想】全面实现流程 · 数据库导出Excel表格文件的接口
37 0

热门文章

最新文章