springBoot swing 介面實現配置和日誌列印

阿新 • • 發佈：2020-07-28

廢話少說，直接貼程式碼，

程式碼全在一個包下面不需要展示目錄結構了。

ConfigFrame

package com.adao.simulater.swing;

import org.apache.log4j.Logger;

import javax.swing.*;
import java.awt.*;

public class ConfigFrame {
    private final static Logger logger = Logger.getLogger(ConfigFrame.class);

    public static void show() {

        JPanel panel  
= new JPanel();
        panel.setLayout(null);
        panel = new ConfigDB().buildJpanel(panel);
        panel = new ConfigSocket().buildJpanel(panel);
        panel = new ConfigEvent().buildJpanel(panel);
        panel = new ConfigTask().buildJpanel(panel);
        panel = new ConfigPrint().buildJpanel(panel);
        buildFrame(panel);
    }

     
protected static JButton buildJButton(String name, int x, int y, int width, int height) {
        JButton button = new JButton(name);
        button.setBounds(x, y, width, height);
        return button;
    }

    // 文字框
    protected JTextField buildJTextField(JTextField jtf, String value, String name, int 
 columns, int x, int y, int width, int height) {
        jtf = new JTextField(columns);
        jtf.setText(value);
        jtf.setName(name);
        jtf.setBounds(x, y, width, height);
        logger.info(name + "======" + value);
        return jtf;
    }

    protected static JLabel buildJLabel(String name, int x, int y, int width, int height) {
        JLabel label = new JLabel(name);
        label.setBounds(x, y, width, height);

        return label;
    }

    protected JLabel buildJBorder(String name, int x, int y, int width, int height) {
        JLabel label = new JLabel();
        label.setBounds(x, y, width, height);
        label.setBorder(BorderFactory.createTitledBorder(name));
        return label;
    }

    protected static void saveResult(String msg) {
        if ("true".equals(msg)) {
            JOptionPane.showMessageDialog(null, "儲存成功！", "提示", JOptionPane.PLAIN_MESSAGE);
        } else {
            Toolkit.getDefaultToolkit().beep();
            JOptionPane.showMessageDialog(null, "儲存異常！", "提示", JOptionPane.ERROR_MESSAGE);
        }
    }

    private static void buildFrame(JComponent component) {
        JFrame frame = new JFrame("Simulater Terminal");
        component.setBounds(0, 0, 1152, 864);
        frame.add(component);
        frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        frame.getContentPane().setLayout(new BorderLayout());
        frame.getContentPane().setLayout(null);
        frame.getContentPane().add(BorderLayout.CENTER, component);
        // 設定視窗最小尺寸
        frame.setMinimumSize(new Dimension(1152, 864));

        frame.pack();
        frame.setLocationRelativeTo(null);
        frame.setVisible(true);
        frame.setResizable(true);
    }


}

ConfigDB

package com.adao.simulater.swing;

import com.linyang.simulater.common.Constant;
import com.linyang.simulater.common.PropertiesUtil;
import com.linyang.simulater.util.ComMethod;
import org.apache.log4j.Logger;
import org.springframework.beans.factory.annotation.Autowired;

import javax.swing.*;
import java.awt.*;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.util.HashMap;
import java.util.Map;

/**
 * @Classname ConfigDB
 * @Date 2020/7/17
 * @Created adao
 */
public class ConfigDB {
    private final static Logger logger = Logger.getLogger(ConfigDB.class);

    @Autowired
    PropertiesUtil propertiesUtil;

    private JTextField urlTextField;
    private JTextField usernameTextField;
    private JTextField passwordTextField;

    public ConfigFrame cf = new ConfigFrame();
    public JPanel buildJpanel(JPanel panel) {
        String url = propertiesUtil.getConUrl();
        String username = propertiesUtil.getConUserName();
        String password = propertiesUtil.getConPassWord();

        int y0 = 0;

        panel.add(cf.buildJBorder("資料庫配置", 5, y0 + 10, 490, 180));

        // URL
        panel.add(cf.buildJLabel("URL：", 15, y0 + 40, 80, 25));
        urlTextField = cf.buildJTextField(urlTextField, url, "dbUrl", 20, 100, y0 + 40, 350, 25);
        panel.add(urlTextField);
        // 使用者名稱
        panel.add(cf.buildJLabel("使用者名稱：", 15, y0 + 70, 80, 25));
        usernameTextField = cf.buildJTextField(usernameTextField, username, "dbUserName", 20, 100, y0 + 70, 165, 25);
        panel.add(usernameTextField);

        // 密碼
        panel.add(cf.buildJLabel("密碼：", 15, y0 + 100, 80, 25));
        passwordTextField = cf.buildJTextField(passwordTextField, password, "dbPassWord", 20, 100, y0 + 100, 165, 25);
        panel.add(passwordTextField);

        // 新增按鈕，繫結事件監聽
        JButton saveButton = cf.buildJButton("儲存", 100, y0 + 140, 80, 25);
        addActionListener(saveButton);
        panel.add(saveButton);

        return panel;
    }

    // 為按鈕繫結監聽
    private void addActionListener(JButton saveButton) {
        saveButton.addActionListener(
                new ActionListener() {
                    @Override
                    public void actionPerformed(ActionEvent e) {
                        activeEvent();
                    }
                });

    }

    // save event
    private void activeEvent() {
        String url = propertiesUtil.getConUrl();
        String username = propertiesUtil.getConUserName();
        String password = propertiesUtil.getConPassWord();
        String textUrl = urlTextField.getText().toString();
        String textUsername = usernameTextField.getText().toString();
        String textPassword = passwordTextField.getText().toString();
        if (ComMethod.isEmpty(textUrl)) {
            Toolkit.getDefaultToolkit().beep();
            JOptionPane.showMessageDialog(null, "請輸入資料庫URL！", "提示", JOptionPane.INFORMATION_MESSAGE);
        } else if (ComMethod.isEmpty(textUsername)) {
            Toolkit.getDefaultToolkit().beep();
            JOptionPane.showMessageDialog(null, "請輸入使用者名稱！", "提示", JOptionPane.INFORMATION_MESSAGE);
        } else if (ComMethod.isEmpty(textPassword)) {
            Toolkit.getDefaultToolkit().beep();
            JOptionPane.showMessageDialog(null, "請輸入密碼！", "提示", JOptionPane.INFORMATION_MESSAGE);
        } else if (url.equals(textUrl) && textUsername.equals(username) && textPassword.equals(password) ) {
            Toolkit.getDefaultToolkit().beep();
            JOptionPane.showMessageDialog(null, "配置引數未更改！", "提示", JOptionPane.INFORMATION_MESSAGE);
        } else {

            propertiesUtil.setConUrl(textUrl);
            propertiesUtil.setConUserName(textUsername);
            propertiesUtil.setConPassWord(textPassword);

        }
    }
}

ConfigEvent

package com.adao.simulater.swing;

import com.adao.simulater.common.Constant;
import com.adao.simulater.common.PropertiesUtil;
import com.adao.simulater.util.ComMethod;
import org.apache.log4j.Logger;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

import javax.annotation.PostConstruct;
import javax.swing.*;
import java.awt.*;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.util.HashMap;
import java.util.Map;

/**
 * @Classname ConfigTask
 * @Date 2020/7/20
 * @Created adao
 */
public class ConfigEvent {
    private final static Logger logger = Logger.getLogger(ConfigEvent.class);

    @Autowired
    PropertiesUtil propertiesUtil;

    private JTextField eventPeriodUnitField;
    private JTextField eventPeriodMinField;
    private JTextField eventPeriodMaxField;

    private ConfigFrame cf = new ConfigFrame();

    public JPanel buildJpanel(JPanel panel) {
        ConfigFrame cf = new ConfigFrame();
        String eventPeriodUnit = String.valueOf(propertiesUtil.getConEventPeriodUnit());
        String eventPeriodMin = String.valueOf(propertiesUtil.getConEventPeriodMin());
        String eventPeriodMax = String.valueOf(propertiesUtil.getConEventPeriodMax());

        int y0 = 360;

        //新增伺服器配置區
        panel.add(cf.buildJBorder("事件配置", 5, y0, 490, 180));
        //事件週期基數unit
        panel.add(cf.buildJLabel("週期基數：", 15, y0 + 30, 80, 25));
        eventPeriodUnitField = cf.buildJTextField(eventPeriodUnitField, eventPeriodUnit, "serverAddr", 20, 100, y0 + 30, 165, 25);
        panel.add(eventPeriodUnitField);
        //事件上報週期範圍最小數
        panel.add(cf.buildJLabel("週期最小數：", 15, y0 + 60, 80, 25));
        eventPeriodMinField = cf.buildJTextField(eventPeriodMinField, eventPeriodMin, "serverPort", 20, 100, y0 + 60, 165, 25);
        panel.add(eventPeriodMinField);

        //事件上報週期範圍最大數
        panel.add(cf.buildJLabel("週期最大數：", 15, y0 + 90, 80, 25));
        eventPeriodMaxField = cf.buildJTextField(eventPeriodMaxField, eventPeriodMax, "serverPort", 20, 100, y0 + 90, 165, 25);
        panel.add(eventPeriodMaxField);

        // 新增按鈕，繫結事件監聽
        JButton saveButton = cf.buildJButton("儲存", 100, y0 + 130, 80, 25);
        addActionListener(saveButton);
        panel.add(saveButton);

        return panel;
    }

    // 為按鈕繫結監聽
    private void addActionListener(JButton button) {
        button.addActionListener(
                new ActionListener() {
                    @Override
                    public void actionPerformed(ActionEvent e) {
                        save();
                    }
                });

    }

    // save event
    private void save() {
        String eventPeriodUnit = String.valueOf(propertiesUtil.getConEventPeriodUnit());
        String eventPeriodMin = String.valueOf(propertiesUtil.getConEventPeriodMin());
        String eventPeriodMax = String.valueOf(propertiesUtil.getConEventPeriodMax());
        String eventPeriodUnitText = eventPeriodUnitField.getText().toString();
        String eventPeriodMinText = eventPeriodMinField.getText().toString();
        String eventPeriodMaxText = eventPeriodMaxField.getText().toString();
        if (ComMethod.isEmpty(eventPeriodUnitText)) {
            Toolkit.getDefaultToolkit().beep();
            JOptionPane.showMessageDialog(null, "請輸入事件上報週期基數（毫秒）！", "提示", JOptionPane.INFORMATION_MESSAGE);
        } else if (ComMethod.isEmpty(eventPeriodMinText)) {
            Toolkit.getDefaultToolkit().beep();
            JOptionPane.showMessageDialog(null, "請輸入事件上報週期隨機最小數！", "提示", JOptionPane.INFORMATION_MESSAGE);
        } else if (ComMethod.isEmpty(eventPeriodMaxText)) {
            Toolkit.getDefaultToolkit().beep();
            JOptionPane.showMessageDialog(null, "請輸入事件上報週期隨機最大數！", "提示", JOptionPane.INFORMATION_MESSAGE);
        } else if (Integer.valueOf(eventPeriodMinText) >= Integer.valueOf(eventPeriodMaxText)) {
            Toolkit.getDefaultToolkit().beep();
            JOptionPane.showMessageDialog(null, "最小數要小於最大數，請修改！", "提示", JOptionPane.INFORMATION_MESSAGE);
        } else if (eventPeriodUnit.equals(eventPeriodUnitText) && eventPeriodMin.equals(eventPeriodMinText) && eventPeriodMax.equals(eventPeriodMaxText) ) {
            Toolkit.getDefaultToolkit().beep();
            JOptionPane.showMessageDialog(null, "配置引數未更改！", "提示", JOptionPane.INFORMATION_MESSAGE);
        } else {
            propertiesUtil.setConEventPeriodUnit(Long.valueOf(eventPeriodUnitText));
            propertiesUtil.setConEventPeriodMin(Integer.valueOf(eventPeriodMinText));
            propertiesUtil.setConEventPeriodMax(Integer.valueOf(eventPeriodMaxText));

        }
    }

}

ConfigPrint

package com.adao.simulater.swing;

import org.apache.log4j.Appender;
import org.apache.log4j.Logger;
import org.apache.log4j.WriterAppender;

import javax.swing.*;
import java.io.PipedReader;
import java.io.PipedWriter;
import java.io.Writer;

public class ConfigPrint {

    JTextArea logTextArea;

    public ConfigFrame cf = new ConfigFrame();

    public JPanel buildJpanel(JPanel panel) {

        int y0 = 0;

        panel.add(cf.buildJBorder("日誌", 500, y0 + 10, 630, 720));

        logTextArea = new JTextArea();
        panel.add(logTextArea);

        JScrollPane logScrollPane = new JScrollPane();
        logScrollPane.setBounds(510, y0 + 40, 610, 680);
        logScrollPane.getViewport().add(logTextArea);
        panel.add(logScrollPane);

        Logger root = Logger.getRootLogger();
        try {
            Appender appender = root.getAppender("WriterAppender");
            PipedReader reader = new PipedReader();
            Writer writer = new PipedWriter(reader);

            ((WriterAppender) appender).setWriter(writer);

            Thread t = new Appendered(reader, logTextArea, logScrollPane);
            t.start();

        } catch (Exception e) {
        }
        return panel;
    }

}

Appendered

package com.adao.simulater.swing;

import javax.swing.*;
import java.io.PipedReader;
import java.util.Scanner;

public class Appendered extends Thread {
    PipedReader reader;
    JTextArea textArea;
    JScrollPane scroll;
   
    public Appendered(PipedReader reader,JTextArea textArea, JScrollPane scroll) {
        this.reader = reader;
        this.textArea=textArea;
        this.scroll=scroll;
        
    }

    public void run() {
        Scanner scanner = new Scanner(reader);
        while (scanner.hasNext()) {
           // System.out.println(scanner.nextLine());
            textArea.append(scanner.nextLine());
            textArea.append("\n");
          //使垂直滾動條自動向下滾動
            scroll.getVerticalScrollBar().setValue(scroll.getVerticalScrollBar().getMaximum());
        }
    }
}

ConfigSocket

package com.adao.simulater.swing;

import com.adao.simulater.common.Constant;
import com.adao.simulater.common.PropertiesUtil;
import com.adao.simulater.util.ComMethod;
import org.apache.log4j.Logger;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

import javax.annotation.PostConstruct;
import javax.swing.*;
import java.awt.*;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.net.InetSocketAddress;
import java.net.Socket;
import java.net.SocketAddress;
import java.util.HashMap;
import java.util.Map;
import java.util.regex.Pattern;

/**
 * @Classname ConfigSocket
 * @Date 2020/7/20
 * @Created YinTao
 */
public class ConfigSocket {
    private final static Logger logger = Logger.getLogger(ConfigDB.class);
    private JTextField serverAddrField;
    private JTextField serverPortField;

    @Autowired
    PropertiesUtil propertiesUtil;

    private ConfigFrame cf = new ConfigFrame();
    public JPanel buildJpanel(JPanel panel) {
        ConfigFrame cf = new ConfigFrame();
        String serverAddr =  propertiesUtil.getConServerAddress();
        String serverPort = String.valueOf(propertiesUtil.getConServerPort());

        int y0 = 200;

        /**
         * 伺服器配置
         */
        //新增伺服器配置區
        panel.add(cf.buildJBorder("Socket服務配置", 5, y0, 490,150));
        //新增伺服器地址標籤
        panel.add(cf.buildJLabel("伺服器地址：", 15, y0 + 30, 80, 25));
        serverAddrField = cf.buildJTextField(serverAddrField, serverAddr, "serverAddr", 20, 100, y0 + 30, 165, 25);
        panel.add(serverAddrField);
        //新增伺服器埠
        panel.add(cf.buildJLabel("伺服器埠：", 15, y0 + 60, 80, 25));
        serverPortField = cf.buildJTextField(serverPortField, serverPort, "serverPort", 20, 100, y0 + 60, 165, 25);
        panel.add(serverPortField);

        //新增儲存按鈕
        JButton linkOrBreak = cf.buildJButton("儲存", 100, y0 + 100, 80, 25);
        addActionListener(linkOrBreak);
        panel.add(linkOrBreak);
        // 新增測試按鈕
        JButton saveButton = cf.buildJButton("測試", 200, y0 + 100, 80, 25);
        addActionListener(saveButton);
        panel.add(saveButton);

        return panel;
    }

    // 為按鈕繫結監聽
    private void addActionListener(JButton saveButton) {
        saveButton.addActionListener(
                new ActionListener() {
                    @Override
                    public void actionPerformed(ActionEvent e) {

                        if(saveButton.getText()=="儲存")
                        {
                            activeEvent();
                        }
                        else if(saveButton.getText()=="測試")
                        {
                            testLink();
                        }

                    }
                });

    }

    // save event
    private void activeEvent() {
        String serverAddr =  propertiesUtil.getConServerAddress();
        String serverPort = String.valueOf(propertiesUtil.getConServerPort());
        String serverAddrText = serverAddrField.getText().toString();
        String serverPortText = serverPortField.getText().toString();
        if (ComMethod.isEmpty(serverAddrText)) {
            Toolkit.getDefaultToolkit().beep();
            JOptionPane.showMessageDialog(null, "請輸入Socker服務地址！", "提示", JOptionPane.INFORMATION_MESSAGE);
        } else if (!ComMethod.isIp(serverAddrText)) {
            Toolkit.getDefaultToolkit().beep();
            JOptionPane.showMessageDialog(null, "Socker 服務地址格式錯誤！", "提示", JOptionPane.INFORMATION_MESSAGE);
        } else if (ComMethod.isEmpty(serverPortText)) {
            Toolkit.getDefaultToolkit().beep();
            JOptionPane.showMessageDialog(null, "請輸入Socker服務埠！", "提示", JOptionPane.INFORMATION_MESSAGE);
        } else if (Integer.valueOf(serverPortText) < 1 || Integer.valueOf(serverPortText) > 65535) {
            Toolkit.getDefaultToolkit().beep();
            JOptionPane.showMessageDialog(null, "埠配置錯誤，或超出範圍[1,65535]", "提示", JOptionPane.INFORMATION_MESSAGE);
        } else if (!Pattern.matches("^\\d{1,5}$", serverPortText)) {
            Toolkit.getDefaultToolkit().beep();
            JOptionPane.showMessageDialog(null, "Socker埠配置錯誤,請輸入數字5位數字", "提示", JOptionPane.INFORMATION_MESSAGE);
        } else if (serverAddr.equals(serverAddrText) && serverPort.equals(serverPortText)) {
            Toolkit.getDefaultToolkit().beep();
            JOptionPane.showMessageDialog(null, "配置引數未更改！", "提示", JOptionPane.INFORMATION_MESSAGE);
        } else {

            propertiesUtil.setConServerAddress(serverAddrText);
            propertiesUtil.setConServerPort(Integer.valueOf(serverPortText));

        }
    }
    // 測試連線
    private void testLink() {
        String serverAddrText = serverAddrField.getText().toString();
        String serverPortText = serverPortField.getText().toString();
        if (ComMethod.isEmpty(serverAddrText)) {
            Toolkit.getDefaultToolkit().beep();
            JOptionPane.showMessageDialog(null, "請輸入Socker服務地址！", "提示", JOptionPane.INFORMATION_MESSAGE);
        } else if (!ComMethod.isIp(serverAddrText)) {
            Toolkit.getDefaultToolkit().beep();
            JOptionPane.showMessageDialog(null, "Socker服務地址格式錯誤！", "提示", JOptionPane.INFORMATION_MESSAGE);
        } else if (ComMethod.isEmpty(serverPortText)) {
            Toolkit.getDefaultToolkit().beep();
            JOptionPane.showMessageDialog(null, "請輸入Socker服務埠！", "提示", JOptionPane.INFORMATION_MESSAGE);
        } else if (Integer.valueOf(serverPortText) < 1 || Integer.valueOf(serverPortText) > 65535) {
            Toolkit.getDefaultToolkit().beep();
            JOptionPane.showMessageDialog(null, "埠配置超出範圍[1,65535]", "提示", JOptionPane.INFORMATION_MESSAGE);
        } else if (!Pattern.matches("^\\d{1,5}$", serverPortText)) {
            Toolkit.getDefaultToolkit().beep();
            JOptionPane.showMessageDialog(null, "Socker埠配置錯誤,請輸入數字5位數字", "提示", JOptionPane.INFORMATION_MESSAGE);
        } else {

            try {
                SocketAddress address = new InetSocketAddress(serverAddrText, Integer.parseInt(serverPortText));
                Socket socket = new Socket();
                socket.connect(address, 2 * 1000);
                socket.close();
                JOptionPane.showMessageDialog(null, "測試連線正常", "提示", JOptionPane.INFORMATION_MESSAGE);

            } catch (Exception e) {
                JOptionPane.showMessageDialog(null, "測試連線異常", "提示", JOptionPane.INFORMATION_MESSAGE);
            }

        }
    }
}

taskStart

package com.adao.simulater.swing;

import com.adao.simulater.common.AppContextUtil;
import com.adao.simulater.common.PropertiesUtil;
import com.adao.simulater.pojo.TaskInfoBean;
import com.adao.simulater.service.FreezeDayService;
import com.adao.simulater.service.TaskService;
import com.adao.simulater.service.impl.TaskServiceImpl;
import com.adao.simulater.task.TaskManager;
import com.adao.simulater.util.ComMethod;
import org.apache.log4j.Logger;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import javax.swing.*;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.awt.event.ItemEvent;
import java.awt.event.ItemListener;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Properties;

/**
 * @Classname ConfigTask
 * @Description TODO
 * @Date 2020/7/21
 * @Created adao
 */
public class ConfigTask {
    private final static Logger logger = Logger.getLogger(ConfigEvent.class);

    @Autowired
    PropertiesUtil propertiesUtil;

    private JButton reportEnd;
    private JButton reportStart;
    private JComboBox codeTypeBox;

    private ConfigFrame cf = new ConfigFrame();
    private static String defaultTest = "-- 選擇要執行的任務名稱 --";
    private static String choseTask = null;

    private AppContextUtil appContextUtil = new AppContextUtil();
    private TaskService taskService = appContextUtil.getContext().getBean(TaskService.class);

    public JPanel buildJpanel(JPanel panel) {
        ConfigFrame cf = new ConfigFrame();

        int y0 = 550;
        List<TaskInfoBean> tasks = taskService.getAllTaskInfo();

        panel.add(cf.buildJBorder("任務配置", 5, y0, 490, 180));
        panel.add(cf.buildJLabel("選擇任務：", 15, y0 + 30, 80, 25));
        codeTypeBox = buildJComboBox( tasks, 100, y0 + 30, 350, 25);
        addItemListener(codeTypeBox);
        panel.add(codeTypeBox);

        //開始上報按鈕
        reportStart = cf.buildJButton("開始上報", 100, y0 + 120, 100, 25);
        addActionListener(reportStart);
        panel.add(reportStart);

        //新增停止上報按鈕
        reportEnd = cf.buildJButton("停止上報", 300, y0 + 120, 100, 25);
        reportEnd.setEnabled(false);
        addActionListener(reportEnd);
        panel.add(reportEnd);
        return panel;
    }

    // 為按鈕繫結監聽
    private void addActionListener(JButton button) {
        button.addActionListener(
                new ActionListener() {
                    @Override
                    public void actionPerformed(ActionEvent e) {
                        if (button.getText() == "開始上報") {
                            taskStart();
                        } else if (button.getText() == "停止上報") {
                            taskStop();
                        }
                    }
                });

    }

    // 為下拉事件監聽器
    private void addItemListener(JComboBox comboBox) {
        comboBox.addItemListener(
                new ItemListener() {
                    @Override
                    public void itemStateChanged(ItemEvent e) {
                        if (e.getStateChange() == ItemEvent.SELECTED) {
                            // 選擇的下拉框選項
                            choseTask = e.getItem().toString();
                        }
                    }
                });

    }

    private static JComboBox buildJComboBox(List<TaskInfoBean> elements, int x, int y, int width, int height) {

        DefaultComboBoxModel codeTypeModel = new DefaultComboBoxModel();
        // elements 下拉框中的選項
        codeTypeModel.addElement(defaultTest);
        for (int i = 0; i < elements.size(); i++) {
            TaskInfoBean taskInfo = elements.get(i);
            String taskName = taskInfo.getTaskName();
            codeTypeModel.addElement(taskName);
        }

        JComboBox codeTypeBox = new JComboBox(codeTypeModel);
        codeTypeBox.setBounds(x, y, width, height);
        return codeTypeBox;
    }

    // 上報開始
    private void taskStart() {
        // 開始執行任務
        if (ComMethod.isEmpty(choseTask) ||  choseTask.equals(defaultTest)){
            JOptionPane.showMessageDialog(null, "選擇要執行的任務名稱！", "提示", JOptionPane.INFORMATION_MESSAGE);
        } else {
            propertiesUtil.setConTaskEnable(true);
           
            TaskManager taskManager = new TaskManager();
            taskManager.init(choseTask);
            reportStart.setEnabled(false);
            reportEnd.setEnabled(true);
            logger.info("客戶端連線成功，上報開始");
        }

    }

    // 上報停止
    private void taskStop() {
        propertiesUtil.setConTaskEnable(false);
       
        reportStart.setEnabled(true);
        reportEnd.setEnabled(false);
        logger.info("上報即將停止，需等待本次全部完成");
    }

}

其他檔案：

PropertiesUtil

package com.adao.simulater.common;

import com.adao.simulater.util.ComMethod;
import org.apache.log4j.Logger;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Component;

import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.util.Map;
import java.util.Properties;

/**
 * 配置
 * @author adao
 */
@Component
public class PropertiesUtil {
    private final static Logger logger = Logger.getLogger(PropertiesUtil.class);

    public static final String propertiesPath = "src/main/resources/constant.properties";

    private static Constant constant;

    @Autowired
    public void setConfig(Constant constant) {
        PropertiesUtil.constant = constant;
    }

    public static boolean getConTaskEnable() {
        return constant.isTaskEnable();
    }

    public static void setConTaskEnable(boolean taskEnable) {
        constant.setTaskEnable(taskEnable);
    }

    public static String getConServerAddress() {
        return constant.getServerAddress();
    }

    public static void setConServerAddress(String serverAddress) {
        constant.setServerAddress(serverAddress);
    }

    public static Integer getConServerPort() {
        return constant.getServerPort();
    }

    public static void setConServerPort(Integer serverPort) {
        constant.setServerPort(serverPort);
    }

    public static Long getConEventPeriodUnit() {
        return constant.getEventPeriodUnit();
    }

    public static void setConEventPeriodUnit(Long eventPeriodUnit) {
        constant.setEventPeriodUnit(eventPeriodUnit);
    }

    public static Integer getConEventPeriodMax() {
        return constant.getEventPeriodMax();
    }

    public static void setConEventPeriodMax(int eventPeriodMax) {
        constant.setEventPeriodMax(eventPeriodMax);
    }

    public static Integer getConEventPeriodMin() {
        return constant.getEventPeriodMin();
    }

    public static void setConEventPeriodMin(Integer eventPeriodMin) {
        constant.setEventPeriodMin(eventPeriodMin);
    }

    public static String getConUrl() {
        return constant.getUrl();
    }

    public static void setConUrl(String url) {
        constant.setUrl(url);
    }

    public static String getConUserName() {
        return constant.getUserName();
    }

    public static void setConUserName(String userName) {
        constant.setUserName(userName);
    }

    public static String getConPassWord() {
        return constant.getPassWord();
    }

    public static void setConPassWord(String passWord) {
        constant.setPassWord(passWord);
    }

    public static boolean getConHeartEnable() {
        return constant.isHeartEnable();
    }


}

Constant

package com.adao.simulater.common;

import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.PropertySource;

/**
 **/
@Configuration
@ConfigurationProperties(prefix = "constant")
@PropertySource(value = "classpath:constant.properties")
public class Constant {

    private boolean taskEnable;
    private Long taskDelay;
    private boolean heartEnable;
    private Long clientHeart;
    private String serverAddress;
    private Integer serverPort;
    private Integer connectTimeout;
    private Long eventPeriodUnit;
    private Integer eventPeriodMax;
    private Integer eventPeriodMin;
    private String url;
    private String userName;
    private String passWord;

    public boolean isTaskEnable() {
        return taskEnable;
    }

    public void setTaskEnable(boolean taskEnable) {
        this.taskEnable = taskEnable;
    }

    public Long getTaskDelay() {
        return taskDelay;
    }

    public void setTaskDelay(Long taskDelay) {
        this.taskDelay = taskDelay;
    }

    public boolean isHeartEnable() {
        return heartEnable;
    }

    public void setHeartEnable(boolean heartEnable) {
        this.heartEnable = heartEnable;
    }

    public Long getClientHeart() {
        return clientHeart;
    }

    public void setClientHeart(Long clientHeart) {
        this.clientHeart = clientHeart;
    }

    public String getServerAddress() {
        return serverAddress;
    }

    public void setServerAddress(String serverAddress) {
        this.serverAddress = serverAddress;
    }

    public Integer getServerPort() {
        return serverPort;
    }

    public void setServerPort(Integer serverPort) {
        this.serverPort = serverPort;
    }

    public Integer getConnectTimeout() {
        return connectTimeout;
    }

    public void setConnectTimeout(Integer connectTimeout) {
        this.connectTimeout = connectTimeout;
    }

    public Long getEventPeriodUnit() {
        return eventPeriodUnit;
    }

    public void setEventPeriodUnit(Long eventPeriodUnit) {
        this.eventPeriodUnit = eventPeriodUnit;
    }

    public Integer getEventPeriodMax() {
        return eventPeriodMax;
    }

    public void setEventPeriodMax(Integer eventPeriodMax) {
        this.eventPeriodMax = eventPeriodMax;
    }

    public Integer getEventPeriodMin() {
        return eventPeriodMin;
    }

    public void setEventPeriodMin(Integer eventPeriodMin) {
        this.eventPeriodMin = eventPeriodMin;
    }

    public String getUrl() {
        return url;
    }

    public void setUrl(String url) {
        this.url = url;
    }

    public String getUserName() {
        return userName;
    }

    public void setUserName(String userName) {
        this.userName = userName;
    }

    public String getPassWord() {
        return passWord;
    }

    public void setPassWord(String passWord) {
        this.passWord = passWord;
    }
}

proterties

constant.taskEnable=true
constant.taskDelay=1000
constant.heartEnable=true
constant.clientHeart=60000
constant.serverAddress=127.0.0.1
constant.serverPort=8511
constant.connectTimeout=3000
constant.eventPeriodUnit=60000
constant.eventPeriodMax=10
constant.eventPeriodMin=1
constant.url=jdbc:oracle:thin:@192.168.127.150:1521:ORCL
constant.userName=coll_platform
constant.passWord=coll_platform

log.properties

log4j.rootLogger=DEBUG,stdout,file,WriterAppender
log4j.additivity.org.apache=true

log4j.appender.stdout=org.apache.log4j.ConsoleAppender
log4j.appender.stdout.threshold=INFO
log4j.appender.stdout.layout=org.apache.log4j.PatternLayout
#log4j.appender.stdout.layout.ConversionPattern=%-5p %c{1}:%L - %m%n
log4j.appender.stdout.layout.ConversionPattern=%d %p [%c] - %m%n

log4j.appender.file=org.apache.log4j.DailyRollingFileAppender
log4j.appender.file.layout=org.apache.log4j.PatternLayout
#log4j.appender.file.DatePattern='.'yyyy-MM-dd-HH-mm
#log4j.appender.file.layout.ConversionPattern=%d{yyyy-MM-dd HH:mm:ss} %-5p %c{1}:%L - %m%n
log4j.appender.file.layout.ConversionPattern=%d{yyyy-MM-dd HH:mm:ss} %d %p [%c] - %m%n
log4j.appender.file.Threshold=INFO
log4j.appender.file.append=true
#log4j.appender.file.File=/workspaces/logs/simulater/simulater.log
log4j.appender.file.File=./logs/simulator.log

log4j.appender.WriterAppender=org.apache.log4j.WriterAppender
log4j.appender.WriterAppender.Threshold=debug
log4j.appender.WriterAppender.layout=org.apache.log4j.PatternLayout
log4j.appender.WriterAppender.layout.ConversionPattern= - %m%n

SimulaterApplication

@SpringBootApplication
// 掃描 mybatis 通用 mapper 所在的包
@MapperScan(basePackages = "com.adao.simulater.mapper")
// 掃描所有包以及相關元件包
@ComponentScan(basePackages = {"com.adao.simulater"})
@EnableConfigurationProperties(Constant.class)
public class SimulaterApplication {
    private final static Logger logger = Logger.getLogger(SimulaterApplication.class);

    public static void main(String[] args) {
        SpringApplication.run(SimulaterApplication.class, args);

        logger.info("程式開始啟動...");

        // 視覺化介面模型
        ConfigFrame cf=new ConfigFrame();
        cf.show();
    }

}

執行結果

springBoot swing 介面實現配置和日誌列印

廢話少說，直接貼程式碼，程式碼全在一個包下面不需要展示目錄結構了。 ConfigFrame

SpringBoot配置logback日誌列印位置以及分割日誌

配置 logback.xml <?xml version=\"1.0\" encoding=\"UTF-8\"?>

java Socket 檔案伺服器(swing介面) 實現客戶端與伺服器的檔案傳輸

前言基於Socket的TCP協議簡單實現客戶端和伺服器之間的檔案傳輸，實現上傳，下載檔案。

springboot CommandLineRunner介面實現自動任務載入功能

CommandLineRunner介面可以實現任務的自動載入，當專案啟動完後，就會自動去執行CommandLineRunner接口裡的run方法，你可以實現多個CommandLineRunner的例項，使用order來控制執行的順序！

java--swing介面實現註冊登入（用文字檔案儲存資料）

技術標籤：java練手javaswing註冊登入txt檔案操作GUI 效果如下圖雖然使用java很久了，但是對於swing的圖形程式設計還是個小白，還有對於檔案io流的操作也幾乎是沒有接觸過，所以今天寫這篇文章來學習一下。用

springboot之nacos的配置和服務發現

一，我們需要引用的包（nacos需對應springboot的2.3.6.RELEASE這個版本） <dependency>

SpringBoot整合nacos實現配置中心（配置動態更新）

官方教程：https://nacos.io/zh-cn/docs/quick-start-spring-boot.html 安裝nacos：https://nacos.io/zh-cn/docs/quick-start.html

【SpringBoot實戰】核心配置和註解

前言 SpringBoot核心配置在springboot中有非常重要的作用，我們可是使用核心配置檔案進行一些基礎功能的定義，屬性值的注入等。springboot支援兩種格式的核心配置檔案，一種是properties和yaml，properties採用傳統的

springboot kafka整合(實現producer和consumer)

本文介紹如何在springboot專案中整合kafka收發message。 1、先解決依賴 springboot相關的依賴我們就不提了，和kafka相關的只依賴一個spring-kafka整合包

SpringBoot的淺淺配置和小整合

SpringBoot的淺淺配置和小整合本文如題，就是淺淺記錄一下學習的過程中一些過程，比較簡單，並沒有多少深度。謝謝！

SpringBoot通過RSA實現使用者名稱和密碼的加密和解密

前言在我們輸入使用者名稱和密碼時，在傳輸的過程中應以加密的方式去傳遞到後臺，尤其是密碼，避免在登入的過程中，開啟瀏覽器的控制檯，便能輕鬆取得密碼。

springboot配置aop切面日誌列印過程解析

這篇文章主要介紹了springboot配置aop切面日誌列印過程解析,文中通過示例程式碼介紹的非常詳細，對大家的學習或者工作具有一定的參考學習價值,需要的朋友可以參考下

使用springboot aop來實現讀寫分離和事物配置

什麼事讀寫分離讀寫分離，基本的原理是讓主資料庫處理事務性增、改、刪操作（INSERT、UPDATE、DELETE），而從資料庫處理SELECT查詢操作。資料庫複製被用來把事務性操作導致的變更同步到叢集中的從資料庫。

SpringBoot同一介面多個實現類配置的例項詳解

SpringBoot專案中可能出現一個介面有多個實現類的情況，如果不進行配置，注入介面時編譯器不知道要注入哪個實現類就會報錯，因此需要進行配置。以下進行舉例：

SpringBoot - 日誌的配置和使用詳解（SLF4j、Logback）

1，基本介紹（1）市面上常見的日誌框架有很多。通常情況下，日誌是由一個抽象層+實現層的組合來搭建的，而使用者通常來說不應該直接使用具體的日誌實現類，應該使用日誌的抽象層。

springboot配置多環境日誌列印

springboot配置多環境日誌列印為什麼要配置？一般開發用windows ，而程式最終多在linux系統上執行，每次打包釋出都要更改對應的配置資訊。

Python-logging模組實現同時向控制檯和檔案列印日誌

Python-logging模組實現同時向控制檯和檔案列印日誌前言在寫我自己的練手專案的時候，需要寫一系列Python指令碼來幫助我進行運維/環境配置，我希望這些指令碼能夠有比較好的日誌記錄。

SpringBoot成長記8：SpringBoot如何實現自動裝配配置和擴充套件

前面我們摸清楚了整個invokeBeanFactoryPostProcessors方法的if-else邏輯和3個for迴圈的核心脈絡邏輯。

springboot 增加介面訪問日誌列印

import lombok.extern.log4j.Log4j2; import org.springframework.stereotype.Component; import org.springframework.web.method.HandlerMethod;

SpringBoot 控制檯日誌列印輸出 Swagger 介面文件地址(轉載)

import lombok.extern.slf4j.Slf4j;import org.springframework.boot.web.context.WebServerInitializedEvent;import org.springframework.context.ApplicationListener;import org.springframework.stereotype.Com

springBoot swing 介面實現配置和日誌列印

相關推薦