使用JFreeChart折线图绘制服务器性能监控图

已于 2023-06-07 13:12:03 修改
阅读量230 收藏
点赞数 1
分类专栏： java 文章标签： 服务器 java servlet
于 2023-06-03 13:47:00 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/penngo/article/details/131020490
版权

从Prometheus读取监控数据，并使用JFreeChart的拆线图生成对应监控图表。
生成图表效果如下
在这里插入图片描述
实现代码
使用的依赖包：

        <dependency>
            <groupId>cn.hutool</groupId>
            <artifactId>hutool-json</artifactId>
            <version>5.8.19</version>
        </dependency>
        <dependency>
            <groupId>cn.hutool</groupId>
            <artifactId>hutool-http</artifactId>
            <version>5.8.19</version>
        </dependency>
        <dependency>
            <groupId>cn.hutool</groupId>
            <artifactId>hutool-core</artifactId>
            <version>5.8.19</version>
        </dependency>
        <dependency>
            <groupId>org.jfree</groupId>
            <artifactId>jfreechart</artifactId>
            <version>1.5.4</version>
        </dependency>

SystemChart.java生成折线图操作类


import cn.hutool.json.JSONObject;
import com.penngo.prometheus.component.PromMetric;
import com.penngo.prometheus.component.UrlInfo;
import org.jfree.chart.*;
import org.jfree.chart.axis.*;
import org.jfree.chart.plot.ValueMarker;
import org.jfree.chart.plot.XYPlot;
import org.jfree.chart.renderer.xy.XYItemRenderer;
import org.jfree.chart.renderer.xy.XYLineAndShapeRenderer;
import org.jfree.chart.title.LegendTitle;
import org.jfree.chart.title.TextTitle;
import org.jfree.chart.ui.*;
import org.jfree.data.time.*;
import org.jfree.data.xy.XYDataset;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import java.awt.*;
import java.awt.geom.Rectangle2D;
import java.io.File;
import java.text.DateFormat;
import java.time.LocalDateTime;
import java.util.List;
import java.util.*;

public class SystemChart {
    private static Logger log = LoggerFactory.getLogger(SystemChart.class);
    
    public static void  createMetricChart(List<PromMetric> metricList, UrlInfo urlInfo, long start, long end){
        TimeSeriesCollection timeseriescollection = new TimeSeriesCollection();
        for(PromMetric promMetric:metricList){
            TimeSeries timeSeries = createTimeSeries(promMetric);
            timeseriescollection.addSeries(timeSeries);
        }

        JFreeChart freeChart = createChart(timeseriescollection, urlInfo, start, end);
        File img = new File("logs/"+urlInfo.getKey()+".png");
//        ImageUtil.saveImage(freeChart, img, 1920, 1080);
        ImageUtil.saveImage(freeChart, img, 1024, 512);
    }

    private static TimeSeries createTimeSeries(PromMetric promMetric){
        JSONObject metric = promMetric.getMetric();
        List<List<Object>> valueList = promMetric.getValues();

        String instance = metric.getStr("instance");
        int instanceIndex = instance.lastIndexOf(":");
        instance = instanceIndex > -1 ? instance.substring(0, instanceIndex) : instance;

        String name = instance;

        TimeSeries timeseries = new TimeSeries(name);

        LocalDateTime localDateTime = null;
        for(List<Object> metricValue:valueList){
            long time = Double.valueOf(metricValue.get(0).toString()).longValue();
            double value = Double.valueOf(metricValue.get(1).toString());
            localDateTime = DateUtil.secondToLocalDateTime(time);
            Day day = new Day(DateUtil.localDateTimeToDate(localDateTime));
            int hour = localDateTime.getHour();
            int minute = localDateTime.getMinute();
            timeseries.add(new Minute(minute, new Hour(hour, day)), value);
        }
        return timeseries;
    }

    private static JFreeChart createChart(XYDataset xydataset,UrlInfo urlInfo, long start, long end)
    {
        LocalDateTime startDate = DateUtil.secondToLocalDateTime(start);
        LocalDateTime endDate = DateUtil.secondToLocalDateTime(end);
        createTheme();
        JFreeChart jfreechart = ChartFactory.createTimeSeriesChart(urlInfo.getTitle(), "", "", xydataset, false, true, false);
        Font titleFont = new Font("宋体", Font.BOLD, 20);
        jfreechart.getTitle().setFont(titleFont);

        // 创建子标题
        createSubTitle(jfreechart, urlInfo);

        jfreechart.setBorderVisible(false);
        XYPlot plot = (XYPlot) jfreechart.getPlot();
        plot.setBackgroundPaint(Color.WHITE);
        plot.setDomainGridlinePaint(Color.lightGray);
        plot.setRangeGridlinePaint(Color.lightGray);
        plot.setAxisOffset(new RectangleInsets(5.0, 5.0, 5.0, 20.0));
        plot.setDomainCrosshairVisible(true);
        plot.setRangeCrosshairVisible(true);
        plot.setInsets(new RectangleInsets(5.0D, 5.0D, 5.0D, 20.0D));

        // 创建折线条标签
        createLegend(jfreechart, plot, xydataset);

        // 线条颜色
        XYItemRenderer r = plot.getRenderer();
        if (r instanceof XYLineAndShapeRenderer) {
            XYLineAndShapeRenderer renderer = (XYLineAndShapeRenderer) r;
            for(int i = 0; i < xydataset.getSeriesCount(); i++){
                renderer.setSeriesPaint(i, ColorUtils.colorlist.get(i).getColor());
                renderer.setSeriesStroke(i, new BasicStroke(2));
            }
        }

        // X轴
        plot.setDomainAxis(new CustomDateAxis(start, end));
        DateAxis dateAxis = (DateAxis) plot.getDomainAxis();
        
        // 设备X轴时间显示最大和最小值
        dateAxis.setRange(DateUtil.localDateTimeToDate(startDate), DateUtil.localDateTimeToDate(endDate));

        // Y轴
        plot.setRangeAxis(new CustomNumberAxis());
        NumberAxis valueAxis = (NumberAxis)plot.getRangeAxis();
        valueAxis.setRange(0,105);

        // 分割线
        createRangeMarker(plot);
        return jfreechart;
    }

    private static void createRangeMarker(XYPlot plot){
        ValueMarker vmarker = new ValueMarker(80d);//设置分割线
        vmarker.setLabel("使用率超过80%性能预警");
        vmarker.setLabelPaint(Color.red);
        vmarker.setPaint(Color.red);
        vmarker.setStroke(new BasicStroke(1.0f,BasicStroke.CAP_BUTT,BasicStroke.JOIN_ROUND,
                1.0f,new float[]{3,3,},0f));
        vmarker.setLabelFont(new Font("宋体",Font.PLAIN,12));
        vmarker.setLabelAnchor(RectangleAnchor.BOTTOM_RIGHT);
        vmarker.setLabelTextAnchor(TextAnchor.TOP_RIGHT);
        plot.addRangeMarker(vmarker);
    }

    private static void createTheme(){
        StandardChartTheme standardChartTheme = new StandardChartTheme("JFree"); //或者为Legacy
        standardChartTheme.setRegularFont(new Font("宋体", Font.PLAIN, 16));
        standardChartTheme.setExtraLargeFont(new Font("宋体", Font.BOLD, 20));
        standardChartTheme.setSmallFont(new Font("宋体", Font.PLAIN, 16));
        standardChartTheme.setLargeFont(new Font("宋体", Font.PLAIN, 16));
        ChartFactory.setChartTheme(standardChartTheme);
    }
    /**
     * 出创建折线条标签
     * @param plot
     */
    private static void createLegend(JFreeChart jfreechart, XYPlot plot, XYDataset xydataset){
        Font itemFont = new Font("宋体", Font.BOLD, 16);
        LegendItemCollection legendItemCollection = new LegendItemCollection();

        List<TimeSeries> serieList = ((TimeSeriesCollection)xydataset).getSeries();
        for(int i = 0; i < serieList.size(); i++){
            TimeSeries series = serieList.get(i);
            LegendItem legendItem = new LegendItem(series.getKey().toString(), null, null, null, new Rectangle2D.Double(-6.0D, -3.0D, 18.0D, 18.0D), ColorUtils.colorlist.get(i).getColor());
            legendItem.setLabelFont(itemFont);
            legendItemCollection.add(legendItem);
        }

        plot.setFixedLegendItems(legendItemCollection);

        LegendTitle var6 = new LegendTitle(plot);
        var6.setPosition(RectangleEdge.BOTTOM);
        jfreechart.addSubtitle(var6);
    }

    private static void createSubTitle(JFreeChart jfreechart, UrlInfo urlInfo){
        Font subTitleFont = new Font("宋体", Font.BOLD, 12);
        TextTitle subtitle1 = new TextTitle("日期：" + DateUtil.getNowStr("yyyy-MM-dd HH:mm:ss"));
        subtitle1.setPaint(new Color(144,144,144));
        subtitle1.setFont(subTitleFont);
        subtitle1.setPosition(RectangleEdge.TOP);
        subtitle1.setHorizontalAlignment(HorizontalAlignment.RIGHT);
        subtitle1.setMargin(0.0D, 0.0D, 0.0D, 50.0D);
        jfreechart.addSubtitle(subtitle1);

        TextTitle subtitle2 = new TextTitle(urlInfo.getSubTitle());
        subtitle2.setPaint(new Color(144,144,144));
        subtitle2.setFont(subTitleFont);
        subtitle2.setPosition(RectangleEdge.BOTTOM);
        subtitle2.setHorizontalAlignment(HorizontalAlignment.CENTER);
        subtitle2.setMargin(4.0D, 0.0D, 2.0D, 4.0D);
        jfreechart.addSubtitle(subtitle2);

        TextTitle subtitle3 = new TextTitle("百分比");
        subtitle3.setPaint(new Color(144,144,144));
        subtitle3.setFont(subTitleFont);
        subtitle3.setPosition(RectangleEdge.TOP);
        subtitle3.setHorizontalAlignment(HorizontalAlignment.LEFT);
        subtitle3.setMargin(-16.0D, 20.0D, 2.0D, 4.0D);
        jfreechart.addSubtitle(subtitle3);
    }

    private static class CustomNumberAxis extends NumberAxis{
        public List refreshTicks(Graphics2D g2, AxisState state, Rectangle2D dataArea, RectangleEdge edge) {
            List result = new ArrayList();

            for(int number = 0; number <= 100; number += 5){
                result.add(new NumberTick(TickType.MINOR, number, number + "%", TextAnchor.CENTER_RIGHT, TextAnchor.CENTER, 0.0));
            }

            return result;
        }
    }
    private static class CustomDateAxis extends DateAxis{
        private long start;
        private long end;
        public CustomDateAxis(long start, long end){
            this.start = start;
            this.end = end;
        }
        public List refreshTicks(Graphics2D g2, AxisState state, Rectangle2D dataArea, RectangleEdge edge) {
            List result = new ArrayList();
            if (RectangleEdge.isTopOrBottom(edge)) {
                Font tickLabelFont = this.getTickLabelFont();
                g2.setFont(tickLabelFont);
                if (this.isAutoTickUnitSelection()) {
                    this.selectAutoTickUnit(g2, dataArea, edge);
                }

                DateTickUnit unit = this.getTickUnit();
                Date tickDate = this.calculateLowestVisibleTickValue(unit);

                for(long index = start; index <= end; index += 3600){
                    LocalDateTime localDateTime = DateUtil.secondToLocalDateTime(index);
                    Date date = DateUtil.localDateTimeToDate(localDateTime);
                    String timeValue = DateUtil.dateToStr(localDateTime, "HH:mm");
                    Tick tick = new DateTick(date, timeValue, TextAnchor.TOP_CENTER, TextAnchor.TOP_CENTER, 0.0);
                    result.add(tick);
                }

            } else if (RectangleEdge.isLeftOrRight(edge)) {
                result = this.refreshTicksVertical(g2, dataArea, edge);
            }
            return result;
        }

        protected List refreshTicksHorizontal(Graphics2D g2, Rectangle2D dataArea, RectangleEdge edge) {
            List result = new ArrayList();
            Font tickLabelFont = this.getTickLabelFont();
            g2.setFont(tickLabelFont);
            if (this.isAutoTickUnitSelection()) {
                this.selectAutoTickUnit(g2, dataArea, edge);
            }

            DateTickUnit unit = this.getTickUnit();
            Date tickDate = this.calculateLowestVisibleTickValue(unit);
            Date upperDate = this.getMaximumDate();
            boolean hasRolled = false;

            while(true) {
                while(tickDate.before(upperDate)) {
                    long lowestTickTime = tickDate.getTime();
                    long distance = unit.addToDate(tickDate, this.getTimeZone()).getTime() - lowestTickTime;
                    int minorTickSpaces = this.getMinorTickCount();
                    if (minorTickSpaces <= 0) {
                        minorTickSpaces = unit.getMinorTickCount();
                    }

                    for(int minorTick = 1; minorTick < minorTickSpaces; ++minorTick) {
                        long minorTickTime = lowestTickTime - distance * (long)minorTick / (long)minorTickSpaces;
                        if (minorTickTime > 0L && this.getRange().contains((double)minorTickTime) && !this.isHiddenValue(minorTickTime)) {
                            result.add(new DateTick(TickType.MINOR, new Date(minorTickTime), "", TextAnchor.TOP_CENTER, TextAnchor.CENTER, 0.0D));
                        }
                    }

                    if (!this.isHiddenValue(tickDate.getTime())) {
                        DateFormat formatter = this.getDateFormatOverride();
                        String tickLabel;
                        if (formatter != null) {
                            tickLabel = formatter.format(tickDate);
                        } else {
                            tickLabel = this.getTickUnit().dateToString(tickDate);
                        }

                        double angle = 0.0D;
                        TextAnchor anchor;
                        TextAnchor rotationAnchor;
                        if (this.isVerticalTickLabels()) {
                            anchor = TextAnchor.CENTER_RIGHT;
                            rotationAnchor = TextAnchor.CENTER_RIGHT;
                            if (edge == RectangleEdge.TOP) {
                                angle = 1.5707963267948966D;
                            } else {
                                angle = -1.5707963267948966D;
                            }
                        } else if (edge == RectangleEdge.TOP) {
                            anchor = TextAnchor.BOTTOM_CENTER;
                            rotationAnchor = TextAnchor.BOTTOM_CENTER;
                        } else {
                            anchor = TextAnchor.TOP_CENTER;
                            rotationAnchor = TextAnchor.TOP_CENTER;
                        }

                        Tick tick = new DateTick(tickDate, tickLabel, anchor, rotationAnchor, angle);
                        result.add(tick);
                        hasRolled = false;
                        long currentTickTime = tickDate.getTime();
                        tickDate = unit.addToDate(tickDate, this.getTimeZone());
                        long nextTickTime = tickDate.getTime();

                        for(int minorTick = 1; minorTick < minorTickSpaces; ++minorTick) {
                            long minorTickTime = currentTickTime + (nextTickTime - currentTickTime) * (long)minorTick / (long)minorTickSpaces;
                            if (this.getRange().contains((double)minorTickTime) && !this.isHiddenValue(minorTickTime)) {
                                result.add(new DateTick(TickType.MINOR, new Date(minorTickTime), "", TextAnchor.TOP_CENTER, TextAnchor.CENTER, 0.0D));
                            }
                        }
                    } else {
                        tickDate = unit.rollDate(tickDate, this.getTimeZone());
                        hasRolled = true;
                    }
                }
                return result;
            }
        }
    }
}


public class PrometheusChart  {
    private static Logger log = LoggerFactory.getLogger(PrometheusCommand.class);
    private final static String server = "http://192.168.28.127:9090/api/v1/query_range?";


    @Override
    public void run(String... args){
        try{

            long end = LocalDateTime.now().toEpochSecond(ZoneOffset.of("+8"));
            long start = end - 24 * 3600;
            List<UrlInfo> urlList = Arrays.asList(
                new UrlInfo("test_cpu", "CPU使用率", "服务器巡检报告","query=process_system_cpu%7Bapp%3D%7E%22city_.*%22%7D&start="+ start + ".453&end=" + end + ".453&step=345")
            );
            for(UrlInfo urlInfo: urlList) {
                log.info("url====" + HttpUtil.createGet(server).form(urlInfo.getParame()).getUrl());
                String result = HttpUtil.get(server + urlInfo.getParame());
                PromResult promResult = JSONUtil.toBean(result, PromResult.class);
                log.info("json====" + JSONUtil.toJsonStr(promResult));
                if(promResult != null && promResult.getStatus().equals("success")){
                    PromData data = promResult.getData();
                    if(data != null && data.getResult() != null){
                        List<PromMetric>  metricList = data.getResult();
                        SystemChart.createMetricChart(metricList, urlInfo, start, end);
                    }
                }
            }

        }
        catch(Exception e){
            log.error("run error====", e);
        }
    }
}
penngo
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
快看！一张思维导图，包罗最全监控体系建设要点
知他人之所知，晓他人之不晓。
12-02 2288
近年来，随着计算机技术的飞速发展，以及行业信息的共享，传统企业的运维己不再固步自封，日新月异的计算技术发展推动着企业云平台的建设，云平台的计算能力为大数据分析提供了基础，而云平台与大数据分析又将推动运维人工智能的发展。 放眼云、大数据、人工智能的运维发展方向的同时，作为运维的生命线，安全生产保障的生命线仍需强调。作为传统企业的安全生产保障，主要以“监、管、控”为核心，其中“监”则主要指的是监控。...
jfreechart折线图demo
04-12
一份非常简单的jfreechart折线图demo！！！！！！！！
JSP利用JFreeChart生成折线图
08-04
JSP利用JFreeChart生成折线图，文档中包含所需jar包，共有四个例子，导入即可运行，内附有说明
jfreechart绘制折线图（平面和3D）
01-14
jfreechart绘制折线图（平面和3D）绝对经典
jfreechart画折线图的方法
08-27
主要为大家详细介绍了jfreechart画折线图的方法，具有一定的参考价值，感兴趣的小伙伴们可以参考一下
大数据运维实战第二十三课 Namenode、Datanode、Nodemanager 等服务状态监控策略
fegus的博客
08-20 1015
Centreon 是一款功能强大的分布式 IT 监控系统，通过第三方组件可以实现对网络、操作系统和应用程序的监控：首先，它是开源的，你可以免费使用它；其次，它的底层采用 centreon-engine（类似 Nagios 的引擎）作为监控软件，同时通过 cbd 模块将监控到的数据定时写入数据库中，而 Centreon 实时从数据库读取该数据并通过 Web 界面展现监控数据；
jfreechart依赖jar包
04-17
java图形化数据分析，生成柱状图，折线图，饼状图等，jfreechart 依赖jar包，主要是java后台的数据图形化处理，导出使用，与前端页面无关，也可生成图片返回给前端
监控组策略应用----组策略结果
weixin_34015860的博客
02-24 148
组策略结果 你使用组策略结果来验证应用到一个计算机和登录到该计算机的用户的组策略设置。虽然这些数据和组策略建模工具产生的数据相似，但从客户计算机的那里的收集到的组策略的最终设置，而不是从域控制器上建模出来的结果集。使用组策略结果得到数据，要求客户计算机必须是Windows XP或Windows Server 2003或Windows 2008。 示例：组策略结果 使用市场部计算机market...
Java学习笔记之JFreeChart详解
com_xpp的专栏
12-10 288
JFreeChart是sourceforge 一个Java开源项目,是一个优秀的Java图表生成插件,它提供了在Java应用程序, Servlet和Jsp下生成各种图片格式的图表,包括柱形图,饼形图,线图,时序图等. JFreeChart依赖于另外一个项目: JCommon JFreeChart项目免费，但文档收费。 l 利用JFreeChart插件生成动态统计图表的...
Jmeter 二次开发
最新发布
ycwdaaaa的博客
01-14 342
很久之前在老东家做性能测试的时候，一开始是使用 LR 的（服务端测试）。在 LR 里写 vuser scripts 去进行 RPC 协议的接口性能测试。但是后来觉得 LR 实在太重了，一般的机器消受不了。而且无法自动化的驱动测试。所以后来引入了 Jmeter。但是 Jmeter 也有它的缺点， 尤其是最后结果统计中那蛋疼的报表简直 low 到爆。所以临走前搞了一次二次封装。增强 jmeter 的特性，可惜只做了比较少的一部分我就离职了。这里我写出来就当抛砖引玉了吧。
利用jfreechart实现温度计监控设备运行
zhaoyl
06-26 283
  /** **QQ:252574345 **MSN:[email protected] */ 最近因为业务需要,希望对一个设备的温度进行监控,为了直观描述其温度变化,所以利用 JFreeChart做了下面的图形 本工程例环境: Jfreechart1.0.6 eclipse 3.2 tomcat 5.0.28     效果如图:     代码如下:(付后下载)   tep...
jfreechart-1.019-jar及依赖.zip
09-28
这个是我文章内资源，提供下载，资源来源于网络，jfreechart生成饼形图所需jar及依赖，如果想找到对应的生成方法，请关注小编，看文章，jfreffchart版本为1.019
jfreechart 1.0.19 源码加文档和依赖包
08-14
包含jfreechart1.0.19版源码和文档以及所依赖的包，包括jcommon-1.0.23，servlet-api-2.3，junit-4.11
JFreeChart折线图的生成方法
08-27
主要为大家详细介绍了JFreeChart折线图的生成方法，具有一定的参考价值，感兴趣的小伙伴们可以参考一下
软件测试过程的监控方法
伤心的辣条
07-28 635
对于软件测试工作，国内大多数企业采用V模型作为测试的标准模型，来规划和设计软件测试流程，指导日常的测试工作，模型如下图所示：
大数据集群部署策略是什么，集群运行状态如何监控，数据怎么采集的，采集后的存储和分析策略是什么？
阿啄debugIT
04-15 1413
前言 集群部署策略是什么，集群运行状态如何监控，数据怎么采集的，采集后的存储和分析策略是什么？ 集群部署策略是什么 简单的节点部署策略 因为在一般情况下，Hadoop节点需要占用的磁盘空间是最紧张的资源，所以最基本的节点部署策略，是按照磁盘空间的大小来考虑的。 首先将所有Hadoop节点按照磁盘空间的要求从大到小进行排序，再将可用的Host按照剩余磁盘空间从大到小进行排序。 第一步将磁盘空间需求最大的Hadoop节点部署到剩余磁盘空间最大的主机上去， 第二步将磁盘空间需求次大的Hadoop节点部署到
app性能测试，获取CPU和内存数据并生成折线图
qq_37605109的博客
03-14 657
APP性能测试，获取CPU和内存指标并生成折线图
JFreeChart基本知识
热门推荐
Stay Hungry , Stay Foolish
03-31 1万+
1 定制图表（Customising Charts） 1.1 简介 JFreeChart的设计的定制功能是非常灵活的。我们可以使用非常多的属性来设置我们图表的外观。主要包括以下几个方面 1)pie charts (2D and 3D)：饼图（平面和立体） 2)bar charts (regular and stacked, with an optional 3D effect)：柱状图
Echarts实时监控（动态排序折线图）
庭前云落的博客
06-16 840
吾之初為，記之以便後日視資。 效果展示 示例代码 <template> <div class="app-container"> <el-row> <el-col :span="24"> <b>Echarts实时监控</b> <el-card style="height: 600px" id="realTime"> </el-card> <
jfreechart折线图
05-20
jfreechart 是一个 Java 的开源图表库，可以用来制作各种类型的图表，包括折线图。 下面是一个简单的 jfreechart 折线图的例子： ```java import org.jfree.chart.ChartFactory; import org.jfree.chart.ChartFrame; import org.jfree.chart.JFreeChart; import org.jfree.data.xy.XYSeries; import org.jfree.data.xy.XYSeriesCollection; public class LineChartExample { public static void main(String[] args) { // 创建一个数据集 XYSeries series = new XYSeries("数据"); series.add(0, 1); series.add(1, 2); series.add(2, 3); series.add(3, 4); series.add(4, 5); XYSeriesCollection dataset = new XYSeriesCollection(); dataset.addSeries(series); // 创建折线图 JFreeChart chart = ChartFactory.createXYLineChart( "折线图", // 图表标题 "X 轴", // X 轴标签 "Y 轴", // Y 轴标签 dataset // 数据集 ); // 显示图表 ChartFrame frame = new ChartFrame("折线图", chart); frame.pack(); frame.setVisible(true); } } ``` 运行结果如下所示： ![jfreechart 折线图](https://i.loli.net/2021/06/25/8D2Wz1IY7w5ZgnG.png) 在这个例子中，我们首先创建了一个 XYSeries 对象，用于存储折线图的数据。然后创建了一个 XYSeriesCollection 对象，并将前面创建的 XYSeries 对象添加到其中。接着创建了一个 JFreeChart 对象，并使用 ChartFactory 类的 createXYLineChart() 方法创建了一个折线图。最后使用 ChartFrame 类将折线图显示出来。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

penngo

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值