如何根据数据库项目数量在JFrame/JPanel中动态创建可变数量的JPanel

Got it, let's walk through how to build this dynamic Swing GUI that fits your requirements perfectly! Here's a step-by-step implementation tailored to your needs:

1. First, map your database data to Java models #

Start by creating simple classes to represent your projects and tasks—this makes it easier to work with database data in your GUI:

// Task model matching your database task table
public class Task {
    private int id;
    private String taskName;
    private String status;

    // Constructor, getters, and setters here
    public Task(int id, String taskName, String status) {
        this.id = id;
        this.taskName = taskName;
        this.status = status;
    }

    // Getters for table population
    public int getId() { return id; }
    public String getTaskName() { return taskName; }
    public String getStatus() { return status; }
}

// Project model matching your database project table
public class Project {
    private int id;
    private String projectName;
    private List<Task> tasks;

    public Project(int id, String projectName, List<Task> tasks) {
        this.id = id;
        this.projectName = projectName;
        this.tasks = tasks;
    }

    // Getters
    public int getId() { return id; }
    public String getProjectName() { return projectName; }
    public List<Task> getTasks() { return tasks; }
}

2. Build a reusable Project Panel (with scrollable task table) #

Each project gets its own panel with a titled border and a scrollable task table—this handles the per-project scrolling you mentioned:

public class ProjectPanel extends JPanel {
    private JTable taskTable;
    private DefaultTableModel tableModel;

    public ProjectPanel(Project project) {
        // Add a titled border with the project name
        setBorder(BorderFactory.createTitledBorder(project.getProjectName()));
        setLayout(new BorderLayout());
        setPreferredSize(new Dimension(750, 200)); // Optional: set a default size

        // Set up the task table model
        tableModel = new DefaultTableModel(
            new String[]{"Task ID", "Task Name", "Status"}, 0
        );
        taskTable = new JTable(tableModel);

        // Populate the table with the project's tasks
        refreshTaskTable(project.getTasks());

        // Wrap the table in a scroll pane for per-project scrolling
        JScrollPane taskScrollPane = new JScrollPane(taskTable);
        add(taskScrollPane, BorderLayout.CENTER);
    }

    // Method to refresh the task table (for when tasks are added to an existing project)
    public void refreshTaskTable(List<Task> updatedTasks) {
        tableModel.setRowCount(0); // Clear existing rows
        for (Task task : updatedTasks) {
            tableModel.addRow(new Object[]{
                task.getId(), task.getTaskName(), task.getStatus()
            });
        }
    }
}

3. Build the main window (with scrollable project container) #

The main window will hold all project panels in a scrollable container, and handle dynamic addition of new projects:

public class MainProjectFrame extends JFrame {
    private JPanel projectContainer;

    public MainProjectFrame() {
        super("Project & Task Manager");
        setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        setSize(800, 600);

        // Set up the container for all project panels
        projectContainer = new JPanel();
        projectContainer.setLayout(new BoxLayout(projectContainer, BoxLayout.Y_AXIS));
        projectContainer.setBorder(BorderFactory.createEmptyBorder(10, 10, 10, 10)); // Add padding
        projectContainer.add(Box.createVerticalStrut(10)); // Spacing at the top

        // Wrap the project container in a scroll pane for overall window scrolling
        JScrollPane mainScrollPane = new JScrollPane(projectContainer);
        add(mainScrollPane, BorderLayout.CENTER);

        // Load existing projects from the database on startup
        loadInitialProjects();
    }

    // Load projects from your database (replace with your JDBC/JPA logic)
    private void loadInitialProjects() {
        // Example: Fetch projects from DB (replace with your actual query)
        List<Project> projects = fetchProjectsFromDatabase();
        
        for (Project project : projects) {
            addNewProjectPanel(project);
        }
    }

    // Call this method to dynamically add a new project panel (when a project is added to DB)
    public void addNewProjectPanel(Project newProject) {
        ProjectPanel newPanel = new ProjectPanel(newProject);
        projectContainer.add(newPanel);
        projectContainer.add(Box.createVerticalStrut(10)); // Spacing between projects
        
        // Force the container to update and show the new panel
        projectContainer.revalidate();
        projectContainer.repaint();
    }

    // Mock method to simulate database fetching (replace with your actual DB code)
    private List<Project> fetchProjectsFromDatabase() {
        List<Project> mockProjects = new ArrayList<>();
        
        // Mock project 1
        List<Task> tasks1 = Arrays.asList(
            new Task(1, "Finalize API specs", "In Progress"),
            new Task(2, "Set up test environment", "Not Started")
        );
        mockProjects.add(new Project(1, "Customer Portal Redesign", tasks1));

        // Mock project 2
        List<Task> tasks2 = Arrays.asList(
            new Task(3, "Deploy v2.3 to production", "Completed"),
            new Task(4, "Fix payment gateway bugs", "In Progress"),
            new Task(5, "Write user documentation", "In Progress")
        );
        mockProjects.add(new Project(2, "E-Commerce Platform Update", tasks2));

        return mockProjects;
    }

    // Launch the GUI (always run Swing code on the EDT)
    public static void main(String[] args) {
        SwingUtilities.invokeLater(() -> {
            new MainProjectFrame().setVisible(true);
        });
    }
}

4. Handling dynamic updates #

• When a new project is added to the database: Call addNewProjectPanel(newProject) from your database listener or business logic (make sure to run this on the EDT with SwingUtilities.invokeLater() if it's triggered asynchronously).
• When tasks are added to an existing project: Keep a reference to the corresponding ProjectPanel instance, then call refreshTaskTable(updatedTasks) to update its table.

Key Tips #

• Always update Swing components on the Event Dispatch Thread (EDT)—use SwingUtilities.invokeLater() for any UI updates triggered by database events or background threads.
• Adjust the preferredSize of ProjectPanel or the layout manager (e.g., switch to GridBagLayout for more control) if you need different project panel sizing/arrangement.
• Add error handling around database queries to avoid crashing the GUI if the database connection fails.

内容的提问来源于stack exchange，提问作者stares_at_flames