脚本之家 服务器常用软件
快捷导航
您的位置：首页 → 软件编程 → java → java监控rtsp流转flv

java实现监控rtsp流转flv方法实例(前端播放,前后端代码都有)

 更新时间：2023年06月30日 10:01:34   作者：心起  
这篇文章主要给大家介绍了关于java实现监控rtsp流转flv的相关资料,文中介绍的是前端播放,前后端代码都有,文中通过实例代码介绍的非常详细,需要的朋友可以参考下

一.服务代码

目录结构

maven配置文件引入坐标:

        <dependency>
            <groupId>org.bytedeco</groupId>
            <artifactId>javacv-platform</artifactId>
            <version>1.5.1</version>
        </dependency>
        <dependency>
            <groupId>javax.xml.bind</groupId>
            <artifactId>jaxb-api</artifactId>
            <version>2.3.0</version>
        </dependency>

服务器代码

controller层:

import com.xr.web.rtspconverterflvspringbootstarter.service.IFLVService;
import io.swagger.annotations.Api;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
 
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
 
/**
 * FLV流转换
 *
 * @author gc.x
 */
@Api(tags = "flv")
@RequestMapping("/flv")
@RestController
public class FLVController {
 
    @Autowired
    private IFLVService service;
 
 
    @GetMapping()
    public void open4(HttpServletResponse response,
                      HttpServletRequest request) {
        String test = "rtsp://admin:sdxr@2022@192.168.0.205:554";
 
        service.open(test, response, request);
    }
}

config层:

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.scheduling.TaskScheduler;
import org.springframework.scheduling.annotation.EnableScheduling;
import org.springframework.scheduling.concurrent.ThreadPoolTaskScheduler;
 
/**
 * 使用多线程执行定时任务
 * 
 * @author gc.x
 *
 */
@Configuration
@EnableScheduling
public class SchedulerConfig {
    @Bean
    public TaskScheduler taskScheduler() {
        ThreadPoolTaskScheduler scheduler = new ThreadPoolTaskScheduler();
        // 线程池大小
        scheduler.setPoolSize(3);
        // 线程名字前缀
        scheduler.setThreadNamePrefix("task-thread-");
        return scheduler;
    }
 
}

factories层:

/**
 * 转换器状态（初始化、打开、关闭、错误、运行）
 * 
 * @author gc.x
 */
public enum ConverterState {
    INITIAL, OPEN, CLOSE, ERROR, RUN
}
import javax.servlet.AsyncContext;
import java.io.IOException;
 
public interface Converter {
 
    /**
     * 获取该转换的key
     */
    public String getKey();
 
    /**
     * 获取该转换的url
     * 
     * @return
     */
    public String getUrl();
 
    /**
     * 添加一个流输出
     * 
     * @param entity
     */
    public void addOutputStreamEntity(String key, AsyncContext entity) throws IOException;
 
    /**
     * 退出转换
     */
    public void exit();
 
    /**
     * 启动
     */
    public void start();
 
}
import com.alibaba.fastjson.util.IOUtils;
import lombok.extern.slf4j.Slf4j;
import org.bytedeco.ffmpeg.avcodec.AVPacket;
import org.bytedeco.ffmpeg.global.avcodec;
import org.bytedeco.javacv.FFmpegFrameGrabber;
import org.bytedeco.javacv.FFmpegFrameRecorder;
import javax.servlet.AsyncContext;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
 
/**
 * javacv转包装<br/>
 * 无须转码，更低的资源消耗，更低的延迟<br/>
 * 确保流来源视频H264格式,音频AAC格式
 * 
 * @author gc.x
 */
@Slf4j
public class ConverterFactories extends Thread implements Converter {
    public volatile boolean runing = true;
    /**
     * 读流器
     */
    private FFmpegFrameGrabber grabber;
    /**
     * 转码器
     */
    private FFmpegFrameRecorder recorder;
    /**
     * 转FLV格式的头信息<br/>
     * 如果有第二个客户端播放首先要返回头信息
     */
    private byte[] headers;
    /**
     * 保存转换好的流
     */
    private ByteArrayOutputStream stream;
    /**
     * 流地址，h264,aac
     */
    private String url;
    /**
     * 流输出
     */
    private List<AsyncContext> outEntitys;
 
    /**
     * key用于表示这个转换器
     */
    private String key;
 
    /**
     * 转换队列
     */
    private Map<String, Converter> factories;
 
    public ConverterFactories(String url, String key, Map<String, Converter> factories, List<AsyncContext> outEntitys) {
        this.url = url;
        this.key = key;
        this.factories = factories;
        this.outEntitys = outEntitys;
    }
 
    @Override
    public void run() {
        boolean isCloseGrabberAndResponse = true;
        try {
            grabber = new FFmpegFrameGrabber(url);
            if ("rtsp".equals(url.substring(0, 4))) {
                grabber.setOption("rtsp_transport", "tcp");
                grabber.setOption("stimeout", "5000000");
            }
            grabber.start();
            if (avcodec.AV_CODEC_ID_H264 == grabber.getVideoCodec()
                    && (grabber.getAudioChannels() == 0 || avcodec.AV_CODEC_ID_AAC == grabber.getAudioCodec())) {
                log.info("this url:{} converterFactories start", url);
                // 来源视频H264格式,音频AAC格式
                // 无须转码，更低的资源消耗，更低的延迟
                stream = new ByteArrayOutputStream();
                recorder = new FFmpegFrameRecorder(stream, grabber.getImageWidth(), grabber.getImageHeight(),
                        grabber.getAudioChannels());
                recorder.setInterleaved(true);
                recorder.setVideoOption("preset", "ultrafast");
                recorder.setVideoOption("tune", "zerolatency");
                recorder.setVideoOption("crf", "25");
                recorder.setFrameRate(grabber.getFrameRate());
                recorder.setSampleRate(grabber.getSampleRate());
                if (grabber.getAudioChannels() > 0) {
                    recorder.setAudioChannels(grabber.getAudioChannels());
                    recorder.setAudioBitrate(grabber.getAudioBitrate());
                    recorder.setAudioCodec(grabber.getAudioCodec());
                }
                recorder.setFormat("flv");
                recorder.setVideoBitrate(grabber.getVideoBitrate());
                recorder.setVideoCodec(grabber.getVideoCodec());
                recorder.start(grabber.getFormatContext());
                if (headers == null) {
                    headers = stream.toByteArray();
                    stream.reset();
                    writeResponse(headers);
                }
                int nullNumber = 0;
                while (runing) {
                    AVPacket k = grabber.grabPacket();
                    if (k != null) {
                        try {
                            recorder.recordPacket(k);
                        } catch (Exception e) {
                        }
                        if (stream.size() > 0) {
                            byte[] b = stream.toByteArray();
                            stream.reset();
                            writeResponse(b);
                            if (outEntitys.isEmpty()) {
                                log.info("没有输出退出");
                                break;
                            }
                        }
                        avcodec.av_packet_unref(k);
                    } else {
                        nullNumber++;
                        if (nullNumber > 200) {
                            break;
                        }
                    }
                    Thread.sleep(5);
                }
            } else {
                isCloseGrabberAndResponse = false;
                // 需要转码为视频H264格式,音频AAC格式
                ConverterTranFactories c = new ConverterTranFactories(url, key, factories, outEntitys, grabber);
                factories.put(key, c);
                c.start();
            }
        } catch (Exception e) {
            log.error(e.getMessage(), e);
        } finally {
            closeConverter(isCloseGrabberAndResponse);
            completeResponse(isCloseGrabberAndResponse);
            log.info("this url:{} converterFactories exit", url);
 
        }
    }
 
    /**
     * 输出FLV视频流
     * 
     * @param b
     */
    public void writeResponse(byte[] b) {
        Iterator<AsyncContext> it = outEntitys.iterator();
        while (it.hasNext()) {
            AsyncContext o = it.next();
            try {
                o.getResponse().getOutputStream().write(b);
            } catch (Exception e) {
                log.info("移除一个输出");
                it.remove();
            }
        }
    }
 
    /**
     * 退出转换
     */
    public void closeConverter(boolean isCloseGrabberAndResponse) {
        if (isCloseGrabberAndResponse) {
            IOUtils.close(grabber);
            factories.remove(this.key);
        }
        IOUtils.close(recorder);
        IOUtils.close(stream);
    }
 
    /**
     * 关闭异步响应
     * 
     * @param isCloseGrabberAndResponse
     */
    public void completeResponse(boolean isCloseGrabberAndResponse) {
        if (isCloseGrabberAndResponse) {
            Iterator<AsyncContext> it = outEntitys.iterator();
            while (it.hasNext()) {
                AsyncContext o = it.next();
                o.complete();
            }
        }
    }
 
    @Override
    public String getKey() {
        return this.key;
    }
 
    @Override
    public String getUrl() {
        return this.url;
    }
 
    @Override
    public void addOutputStreamEntity(String key, AsyncContext entity) throws IOException {
        if (headers == null) {
            outEntitys.add(entity);
        } else {
            entity.getResponse().getOutputStream().write(headers);
            entity.getResponse().getOutputStream().flush();
            outEntitys.add(entity);
        }
    }
 
    @Override
    public void exit() {
        this.runing = false;
        try {
            this.join();
        } catch (Exception e) {
            log.error(e.getMessage(), e);
        }
    }
 
}
import com.alibaba.fastjson.util.IOUtils;
import lombok.extern.slf4j.Slf4j;
import org.bytedeco.ffmpeg.global.avcodec;
import org.bytedeco.javacv.FFmpegFrameGrabber;
import org.bytedeco.javacv.FFmpegFrameRecorder;
import org.bytedeco.javacv.Frame;
 
import javax.servlet.AsyncContext;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
 
/**
 * javacv转码<br/>
 * 流来源不是视频H264格式,音频AAC格式 转码为视频H264格式,音频AAC格式
 * 
 * @author gc.x
 */
@Slf4j
public class ConverterTranFactories extends Thread implements Converter {
    public volatile boolean runing = true;
    /**
     * 读流器
     */
    private FFmpegFrameGrabber grabber;
    /**
     * 转码器
     */
    private FFmpegFrameRecorder recorder;
    /**
     * 转FLV格式的头信息<br/>
     * 如果有第二个客户端播放首先要返回头信息
     */
    private byte[] headers;
    /**
     * 保存转换好的流
     */
    private ByteArrayOutputStream stream;
    /**
     * 流地址，h264,aac
     */
    private String url;
    /**
     * 流输出
     */
    private List<AsyncContext> outEntitys;
 
    /**
     * key用于表示这个转换器
     */
    private String key;
 
    /**
     * 转换队列
     */
    private Map<String, Converter> factories;
 
    public ConverterTranFactories(String url, String key, Map<String, Converter> factories,
            List<AsyncContext> outEntitys, FFmpegFrameGrabber grabber) {
        this.url = url;
        this.key = key;
        this.factories = factories;
        this.outEntitys = outEntitys;
        this.grabber = grabber;
    }
 
    @Override
    public void run() {
        try {
            log.info("this url:{} converterTranFactories start", url);
            grabber.setFrameRate(25);
            if (grabber.getImageWidth() > 1920) {
                grabber.setImageWidth(1920);
            }
            if (grabber.getImageHeight() > 1080) {
                grabber.setImageHeight(1080);
            }
            stream = new ByteArrayOutputStream();
            recorder = new FFmpegFrameRecorder(stream, grabber.getImageWidth(), grabber.getImageHeight(),
                    grabber.getAudioChannels());
            recorder.setInterleaved(true);
            recorder.setVideoOption("preset", "ultrafast");
            recorder.setVideoOption("tune", "zerolatency");
            recorder.setVideoOption("crf", "25");
            recorder.setGopSize(50);
            recorder.setFrameRate(25);
            recorder.setSampleRate(grabber.getSampleRate());
            if (grabber.getAudioChannels() > 0) {
                recorder.setAudioChannels(grabber.getAudioChannels());
                recorder.setAudioBitrate(grabber.getAudioBitrate());
                recorder.setAudioCodec(avcodec.AV_CODEC_ID_AAC);
            }
            recorder.setFormat("flv");
            recorder.setVideoBitrate(grabber.getVideoBitrate());
            recorder.setVideoCodec(avcodec.AV_CODEC_ID_H264);
            recorder.start();
            if (headers == null) {
                headers = stream.toByteArray();
                stream.reset();
                writeResponse(headers);
            }
            int nullNumber = 0;
            while (runing) {
                // 抓取一帧
                Frame f = grabber.grab();
                if (f != null) {
                    try {
                        // 转码
                        recorder.record(f);
                    } catch (Exception e) {
                    }
                    if (stream.size() > 0) {
                        byte[] b = stream.toByteArray();
                        stream.reset();
                        writeResponse(b);
                        if (outEntitys.isEmpty()) {
                            log.info("没有输出退出");
                            break;
                        }
                    }
                } else {
                    nullNumber++;
                    if (nullNumber > 200) {
                        break;
                    }
                }
                Thread.sleep(5);
            }
        } catch (Exception e) {
            log.error(e.getMessage(), e);
        } finally {
            closeConverter();
            completeResponse();
            log.info("this url:{} converterTranFactories exit", url);
            factories.remove(this.key);
        }
    }
 
    /**
     * 输出FLV视频流
     * 
     * @param b
     */
    public void writeResponse(byte[] b) {
        Iterator<AsyncContext> it = outEntitys.iterator();
        while (it.hasNext()) {
            AsyncContext o = it.next();
            try {
                o.getResponse().getOutputStream().write(b);
            } catch (Exception e) {
                log.info("移除一个输出");
                it.remove();
            }
        }
    }
 
    /**
     * 退出转换
     */
    public void closeConverter() {
        IOUtils.close(grabber);
        IOUtils.close(recorder);
        IOUtils.close(stream);
    }
 
    /**
     * 关闭异步响应
     */
    public void completeResponse() {
        Iterator<AsyncContext> it = outEntitys.iterator();
        while (it.hasNext()) {
            AsyncContext o = it.next();
            o.complete();
        }
    }
 
    @Override
    public String getKey() {
        return this.key;
    }
 
    @Override
    public String getUrl() {
        return this.url;
    }
 
    @Override
    public void addOutputStreamEntity(String key, AsyncContext entity) throws IOException {
        if (headers == null) {
            outEntitys.add(entity);
        } else {
            entity.getResponse().getOutputStream().write(headers);
            entity.getResponse().getOutputStream().flush();
            outEntitys.add(entity);
        }
    }
 
    @Override
    public void exit() {
        this.runing = false;
        try {
            this.join();
        } catch (Exception e) {
            log.error(e.getMessage(), e);
        }
    }
 
}

result层:

import com.alibaba.fastjson.JSONObject;
 
import java.io.Serializable;
import java.util.HashMap;
 
/**
 * 封装返回结果
 * 
 */
public class JsonResult extends HashMap<String, Object> implements Serializable {
 
    private static final long serialVersionUID = 1L;
    public static final int SUCCESS = 200;
 
    public JsonResult() {
    }
 
    /**
     * 返回成功
     */
    public static JsonResult ok() {
        return ok("操作成功");
    }
 
    /**
     * 返回成功
     */
    public static JsonResult okFallBack() {
        return okFallBack("操作成功");
    }
 
    /**
     * 返回成功
     */
    public JsonResult put(Object obj) {
        return this.put("data", obj);
    }
 
    /**
     * 返回成功
     */
    public static JsonResult ok(String message) {
        return result(200, message);
    }
 
    /**
     * 降级函数 - 返回成功
     */
    public static JsonResult okFallBack(String message) {
        return result(205, message);
    }
 
    /**
     * 返回成功
     */
    public static JsonResult result(int code, String message) {
        JsonResult jsonResult = new JsonResult();
        jsonResult.put("timestamp", System.currentTimeMillis());
        jsonResult.put("status", code);
        jsonResult.put("message", message);
        return jsonResult;
    }
 
    /**
     * 返回失败
     */
    public static JsonResult error() {
        return error("操作失败");
    }
 
    /**
     * 返回失败
     */
    public static JsonResult error(String message) {
        return error(500, message);
    }
 
    /**
     * 返回失败
     */
    public static JsonResult error(int code, String message) {
        JsonResult jsonResult = new JsonResult();
        jsonResult.put("timestamp", System.currentTimeMillis());
        jsonResult.put("status", code);
        jsonResult.put("message", message);
        return jsonResult;
    }
 
    /**
     * 设置code
     */
    public JsonResult setCode(int code) {
        super.put("status", code);
        return this;
    }
 
    /**
     * 设置message
     */
    public JsonResult setMessage(String message) {
        super.put("message", message);
        return this;
    }
 
    /**
     * 放入object
     */
    @Override
    public JsonResult put(String key, Object object) {
        super.put(key, object);
        return this;
    }
 
    /**
     * 权限禁止
     */
    public static JsonResult forbidden(String message) {
        JsonResult jsonResult = new JsonResult();
        jsonResult.put("timestamp", System.currentTimeMillis());
        jsonResult.put("status", 401);
        jsonResult.put("message", message);
        return jsonResult;
    }
 
    @Override
    public String toString() {
        return JSONObject.toJSONString(this);
    }
 
    public JSONObject toJSONObject() {
        return JSONObject.parseObject(toString());
    }
 
}

service层:

import com.alibaba.fastjson.JSONObject;
 
import java.io.Serializable;
import java.util.HashMap;
 
/**
 * 封装返回结果
 * 
 */
public class JsonResult extends HashMap<String, Object> implements Serializable {
 
    private static final long serialVersionUID = 1L;
    public static final int SUCCESS = 200;
 
    public JsonResult() {
    }
 
    /**
     * 返回成功
     */
    public static JsonResult ok() {
        return ok("操作成功");
    }
 
    /**
     * 返回成功
     */
    public static JsonResult okFallBack() {
        return okFallBack("操作成功");
    }
 
    /**
     * 返回成功
     */
    public JsonResult put(Object obj) {
        return this.put("data", obj);
    }
 
    /**
     * 返回成功
     */
    public static JsonResult ok(String message) {
        return result(200, message);
    }
 
    /**
     * 降级函数 - 返回成功
     */
    public static JsonResult okFallBack(String message) {
        return result(205, message);
    }
 
    /**
     * 返回成功
     */
    public static JsonResult result(int code, String message) {
        JsonResult jsonResult = new JsonResult();
        jsonResult.put("timestamp", System.currentTimeMillis());
        jsonResult.put("status", code);
        jsonResult.put("message", message);
        return jsonResult;
    }
 
    /**
     * 返回失败
     */
    public static JsonResult error() {
        return error("操作失败");
    }
 
    /**
     * 返回失败
     */
    public static JsonResult error(String message) {
        return error(500, message);
    }
 
    /**
     * 返回失败
     */
    public static JsonResult error(int code, String message) {
        JsonResult jsonResult = new JsonResult();
        jsonResult.put("timestamp", System.currentTimeMillis());
        jsonResult.put("status", code);
        jsonResult.put("message", message);
        return jsonResult;
    }
 
    /**
     * 设置code
     */
    public JsonResult setCode(int code) {
        super.put("status", code);
        return this;
    }
 
    /**
     * 设置message
     */
    public JsonResult setMessage(String message) {
        super.put("message", message);
        return this;
    }
 
    /**
     * 放入object
     */
    @Override
    public JsonResult put(String key, Object object) {
        super.put(key, object);
        return this;
    }
 
    /**
     * 权限禁止
     */
    public static JsonResult forbidden(String message) {
        JsonResult jsonResult = new JsonResult();
        jsonResult.put("timestamp", System.currentTimeMillis());
        jsonResult.put("status", 401);
        jsonResult.put("message", message);
        return jsonResult;
    }
 
    @Override
    public String toString() {
        return JSONObject.toJSONString(this);
    }
 
    public JSONObject toJSONObject() {
        return JSONObject.parseObject(toString());
    }
 
}
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
public interface IFLVService {
    /**
     * 打开一个流地址
     * 
     * @param url
     * @param response
     */
    public void open(String url, HttpServletResponse response, HttpServletRequest request);
}

二.客户端代码基于flv.js进行播放

<!-- @format -->
<!DOCTYPE html>
<html lang="en">
    <head>
        <meta charset="UTF-8" />
        <meta http-equiv="X-UA-Compatible" content="IE=edge" />
        <meta name="viewport" content="width=device-width, initial-scale=1.0" />
        <title>Document</title>
    </head>
    <body>
        <script src="flv.min.js"></script>
        <video id="videoElement"></video>
        <button onclick="playflv()">点击播放</button>
        <script>
            if (flvjs.isSupported()) {
                var videoElement = document.getElementById('videoElement');
                var flvPlayer = flvjs.createPlayer({
                    type: 'flv',
                    url: 'http://127.0.0.1:10010/xr/flv',
                });
                flvPlayer.attachMediaElement(videoElement);
                flvPlayer.load();
            }
            //自动播放,浏览器不支持
            function playflv() {
                flvPlayer.play();
            }
        </script>
    </body>
</html>

这里因为浏览器把自动播放给禁止了，加了个按钮点击事件

https://www.bootcdn.cn/

引入的flv.js文件在如下网站下载即可:

总结

到此这篇关于java实现监控rtsp流转flv的文章就介绍到这了,更多相关java监控rtsp流转flv内容请搜索脚本之家以前的文章或继续浏览下面的相关文章希望大家以后多多支持脚本之家！

相关文章

  • 非maven项目快速转换为maven项目的方法步骤

    非maven项目快速转换为maven项目的方法步骤

    时候我们导入的项目并不是有maven来管理依赖的,而是要手动添加jar包,比较麻烦,本文主要介绍了非maven项目快速转换为maven项目的方法步骤,具有一定的参考价值,感兴趣的可以了解一下
    2024-01-01
  • java线程之用Thread类创建线程的方法

    java线程之用Thread类创建线程的方法

    本篇文章介绍了，Thread类创建线程的方法。需要的朋友参考下
    2013-05-05
  • Java内存模型之happens-before概念详解

    Java内存模型之happens-before概念详解

    happens-before原则非常重要，它是判断数据是否存在竞争、线程是否安全的主要依据，依靠这个原则，我们解决在并发环境下两操作之间是否可能存在冲突的所有问题。下面我们就一个简单的例子稍微了解下happens-before知识，感兴趣的朋友一起看看吧
    2021-06-06
  • 新手初学Java集合框架

    新手初学Java集合框架

    这篇文章主要介绍了JAVA集合框架的相关知识，文中讲解非常细致，帮助大家更好的理解学习JAVA框架，感兴趣的朋友快来了解下，希望能给你带来帮助
    2021-07-07
  • MyBatis-Plus乐观锁插件的用法小结

    MyBatis-Plus乐观锁插件的用法小结

    乐观锁很乐观，对任何事情都保持着一个乐观的态度，认为别人不会修改数据，所以不会上锁，只是在更新数据的时候，去判断这条数据有没有被别人修改过，这篇文章主要介绍了MyBatis-Plus乐观锁插件的用法,需要的朋友可以参考下
    2022-08-08
  • Java 在线考试云平台的实现

    Java 在线考试云平台的实现

    读万卷书不如行万里路，只学书上的理论是远远不够的，只有在实战中才能获得能力的提升，本篇文章手把手带你用java+vue+springboot+mysql+maven实现一个前端vue后台java微服务的在线考试系统,大家可以在过程中查缺补漏，提升水平
    2021-11-11
  • Java 获取本机IP地址的实例代码

    Java 获取本机IP地址的实例代码

    这篇文章主要介绍了Java 获取本机IP地址,本文通过实例代码给大家介绍的非常详细，需要的朋友可以参考下
    2022-05-05
  • Spring Cloud Gateway打造可扩展的微服务网关

    Spring Cloud Gateway打造可扩展的微服务网关

    微服务网关是一个位于客户端和后端微服务之间的服务器,用于处理所有与客户端的通信,Spring Cloud Gateway都是一个值得考虑的选择,它将帮助您更好地管理和保护您的微服务,感兴趣的朋友一起看看吧
    2023-11-11
  • 更改eclipse的JDK版本详细步骤

    更改eclipse的JDK版本详细步骤

    我们用eclipse在做项目的时候会切换jdk版本,本地运行的项目所使用的jdk版本比Linux服务器高(低),需要调低(高)JDK版本,这篇文章主要给大家介绍了关于如何更改eclipse的JDK版本的相关资料,需要的朋友可以参考下
    2023-11-11
  • SpringBoot 2.0 整合sharding-jdbc中间件实现数据分库分表

    SpringBoot 2.0 整合sharding-jdbc中间件实现数据分库分表

    这篇文章主要介绍了SpringBoot 2.0 整合sharding-jdbc中间件，实现数据分库分表，本文图文并茂给大家介绍的非常详细，具有一定的参考借鉴价值 ,需要的朋友可以参考下
    2019-06-06

最新评论