Sistema de Serviços JavaFX - Professor Clayton Andrade

Sistema de ServiçosJavaFX

Tela Inicial

Nesta configuração, utilizamos um menu de navegação que contém três principais categorias: Cadastro, Consulta e Ordem de Serviço. Cada categoria é composta por itens de menu que permitem ao usuário realizar ações específicas, como cadastrar técnicos ou consultar clientes. A estrutura hierárquica do menu facilita a navegação e a localização das funcionalidades desejadas.

Passo a Passo para Criar o Arquivo XML

Navegar até a Pasta de Recursos:
- No painel do projeto, expanda a pasta resources.
- Navegue até o caminho br/com/professorclaytonandrade/sistemaservicojavafx.
Criar o Arquivo XML:
- Clique com o botão direito do mouse na pasta sistemaservicojavafx.
- No menu de contexto que aparece, selecione New (Novo) e, em seguida, clique em File (Arquivo).
Nomear o Arquivo:
- Digite start-view.fxml como o nome do arquivo e pressione Enter.
- Certifique-se de que a extensão do arquivo seja .fxml.

ProjetoJavaFX/
│
├── src/
│   ├── br.com.professorclaytonandrade.sistemaservicojavafx
│   │   ├── controller
│   │   │   ├── StartViewController.java  // Controlador para a tela inicial
│   │   └── model
│   │   │   ├── ...                       // Modelos de dados (opcional)
│   │   └── ...                           // Outros pacotes
│   │   │   └── ...│
├── resources/
│   ├── br.com.professorclaytonandrade.sistemaservicojavafx
│   │   ├── start-view.fxml              // Arquivo XML da tela inicial
│   │   └── ...                          // Outros arquivos de visualização
│   └── ...                              // Outros pacotes
│   │   └── ...
└── ...

Criando os Componentes da Tela Principal:
- Obeserve o vídeo para entender as configurações dos componentes da tela.

Código FXML:
- Depois de criar o arquivo e criar os componentes, o código start-view.fxml deve ficar mais ou menos assim:

<?xml version="1.0" encoding="UTF-8"?>

<?import javafx.geometry.Insets?>
<?import javafx.scene.control.Menu?>
<?import javafx.scene.control.MenuBar?>
<?import javafx.scene.control.MenuItem?>
<?import javafx.scene.layout.AnchorPane?>
<?import javafx.scene.layout.VBox?>

<VBox prefHeight="740.0" prefWidth="1025.0"
      xmlns="http://javafx.com/javafx/22" 
      xmlns:fx="http://javafx.com/fxml/1"
      fx:controller="br.com.professorclaytonandrade.sistemaservicojavafx.controller.StartViewController">
   <children>
      <MenuBar minHeight="35.0">
        <menus>
          <Menu mnemonicParsing="false" text="Cadastro">
            <items>
              <MenuItem fx:id="menuItemCadastroTecnico" mnemonicParsing="false" 
                    onAction="#mostrarCadastroTecnico" text="Cadastro Técnico"/>
              <MenuItem fx:id="menuItemCadastroCliente" mnemonicParsing="false" text="Cadastro Cliente"/>
            </items>
          </Menu>
          <Menu mnemonicParsing="false" text="Consulta">
            <items>
              <MenuItem fx:id="menuItemCadastroTecnico1" mnemonicParsing="false" 
                    onAction="#mostrarConsultaTecnico" text="Consulta Técnico" />
              <MenuItem fx:id="menuItemCadastroCliente1" mnemonicParsing="false" 
                    text="Consulta Cliente"/>
            </items>
          </Menu>
          <Menu mnemonicParsing="false" text="Ordem Serviço">
            <items>
              <MenuItem fx:id="menuItemNovoChamado" mnemonicParsing="false" text="Novo Chamado"/>
            </items>
          </Menu>
        </menus>
        <VBox.margin>
            <Insets />
        </VBox.margin>
        <padding>
            <Insets bottom="5.0" top="5.0" />
        </padding>
      </MenuBar>
      <AnchorPane fx:id="anchorPane" prefHeight="722.0" prefWidth="1025.0" />
   </children>
</VBox>
    <TextField fx:id="nomeField" promptText="Nome"/>
    <TextField fx:id="idadeField" promptText="Idade"/>
    <Button fx:id="cadastrarButton" text="Cadastrar" onAction="#cadastrarPessoa"/>
</VBox>

Código Java Tela Inicial

A introdução de um código JavaFX com controladores segue o padrão de organização da interface gráfica de uma aplicação, separando a lógica do controle da exibição visual. O controlador (Controller) é responsável por gerenciar a interação entre os componentes da interface e as ações do usuário. Neste exemplo, temos a classe StartViewController, que faz a interface com o layout FXML e manipula a exibição de janelas modais para cadastro e consulta de técnicos.

Abaixo está uma descrição passo a passo do funcionamento do código, que ilustra como essa separação de responsabilidades é realizada dentro de um projeto JavaFX:

1.Declaração do pacote e importações:
- O arquivo começa com a declaração do pacote br.com.professorclaytonandrade.sistemaservicojavafx.controller, indicando que o controlador faz parte desse pacote (Nesse caso o pacote deverá ser o seu!).
- O código importa algumas bibliotecas essenciais, como Util (Vamos Implementar abaixo) para manusear janelas modais, FXML para identificar componentes do arquivo FXML, AnchorPane para trabalhar com o layout da interface, e IOException para tratar exceções relacionadas a arquivos.

package br.com.professorclaytonandrade.sistemaservicojavafx.controller;

import br.com.professorclaytonandrade.sistemaservicojavafx.util.Util;
import javafx.fxml.FXML;
import javafx.scene.layout.AnchorPane;
import java.io.IOException;

2.Declaração dos componentes:
- A classe StartViewController é definida, que será o controlador da interface gráfica.
- O campo anchorPane é anotado com @FXML, o que significa que ele será injetado pelo JavaFX com base no arquivo FXML correspondente. Este AnchorPane é a área onde as janelas modais serão exibidas.
- O campo globalAnchorPane é declarado como static, o que permitirá acessá-lo globalmente dentro da classe e em outros lugares, se necessário.

public class StartViewController {
    @FXML
    private AnchorPane anchorPane;
    
    private static AnchorPane globalAnchorPane;
}

3. Construtor da classe:

- O construtor padrão da classe StartViewController é definido, mas está vazio. Neste caso, o construtor não faz nenhuma ação específica durante a inicialização da classe, vamos usar ele posteriormente.

public StartViewController() {
}

4. Método initialize:
- Este método é chamado automaticamente pelo JavaFX logo após os componentes FXML serem injetados.
- A função de initialize é armazenar a referência do anchorPane na variável globalAnchorPane, permitindo o acesso global desse AnchorPane.

@FXML
public void initialize() {
    globalAnchorPane = anchorPane;
}

5. Método mostrarCadastroTecnico:
- Este método é chamado quando o usuário interage com um item de menu de “Cadastro Técnico”.
- O método utiliza uma função utilitária janelaModal (da classe Util) para abrir uma janela modal carregando o arquivo FXML cadastro-tecnico.fxml.
- Se houver um problema ao carregar o arquivo FXML, ele lança uma exceção IOException.

@FXML
public void mostrarCadastroTecnico() throws IOException {
    Util.janelaModal(globalAnchorPane, "cadastro-tecnico.fxml", "Cadastro Técnico");
}

6. Método mostrarConsultaTecnico:
- Este método funciona de maneira similar ao método anterior, mas abre a interface de “Consulta Técnico”, carregando o arquivo FXML consulta-tecnico.fxml para a janela modal.
- Também pode lançar uma exceção IOException se houver algum problema ao carregar o arquivo.

@FXML
public void mostrarConsultaTecnico() throws IOException {
    Util.janelaModal(globalAnchorPane, "consulta-tecnico.fxml", "Consulta Técnico");
}

7. Método mostrarTelaEditar
- Este método genérico será implementado no futuro para exibir uma tela de edição de dados.
- Aceita parâmetros do tipo genérico T, o nome do arquivo da tela, o título da janela e um controlador personalizado.
- Utiliza o método janelaModalComDados da classe Util, permitindo que dados sejam passados para a tela modal e retornando um booleano para indicar sucesso ou falha.
- Também lança uma exceção IOException em caso de falha ao carregar a tela.

   public static  boolean mostrarTelaEditar(String telaEdicao, String tituloTela, T objeto, Object controller) throws IOException {
        return Util.janelaModalComDados(globalAnchorPane, telaEdicao, tituloTela, objeto, controller);
    }

8. Código StartViewController
- O código completo da implementação deve ficar assim:

package br.com.professorclaytonandrade.sistemaservicojavafx.controller;

import br.com.professorclaytonandrade.sistemaservicojavafx.util.Util;
import javafx.fxml.FXML;

import javafx.scene.layout.AnchorPane;

import java.io.IOException;

public class StartViewController {

    @FXML
    private AnchorPane anchorPane;

    private static AnchorPane globalAnchorPane;

    public StartViewController() {
    }

    @FXML
    public void initialize() {
        globalAnchorPane = anchorPane; // Armazenar referência do AnchorPane
    }

    @FXML
    public void mostrarCadastroTecnico() throws IOException {
        Util.janelaModal(globalAnchorPane, "cadastro-tecnico.fxml", "Cadastro Técnico");
    }

    @FXML
    public void mostrarConsultaTecnico() throws IOException {
        Util.janelaModal(globalAnchorPane, "consulta-tecnico.fxml", "Consulta Técnico");
    }

    public static  boolean mostrarTelaEditar(String telaEdicao, String tituloTela, 
                                              T objeto, Object controller) throws IOException {
        return Util.janelaModalComDados(globalAnchorPane, telaEdicao, tituloTela, objeto, controller);
    }
}

Resumo do Funcionamento Geral:
- O controlador StartViewController gerencia a interface inicial da aplicação.
- Ele faz uso de um AnchorPane para carregar janelas modais, como formulários de cadastro e consulta de técnicos.
- Utiliza a classe utilitária Util para abrir essas janelas em modo modal, onde novos arquivos FXML são carregados.
- O código lida com a exibição de duas diferentes telas: uma para cadastro e outra para consulta de técnicos.

Código Java Main (StartApplication)

O código da classe StartApplication é o ponto de partida de uma aplicação JavaFX. Ele realiza a inicialização do banco de dados, carrega a interface de usuário (UI) a partir de um arquivo FXML, e configura a janela principal onde a aplicação será exibida. Além disso, o código usa o conceito de migração de banco de dados, onde, em uma futura implementação, o banco será inicializado com as versões corretas e as migrações necessárias serão aplicadas.

1.Declaração do pacote e importações:
- Declaração do Pacote:
  A classe pertence ao pacote br.com.professorclaytonandrade.sistemaservicojavafx. Isso ajuda a organizar o código dentro de um projeto maior.
- Importações:
  O código importa pacotes essenciais:
  - javafx.application.Application: Necessário para criar uma aplicação JavaFX.
  - javafx.fxml.FXMLLoader: Carrega arquivos FXML para definir a interface do usuário.
  - javafx.scene.Parent: Representa o nó raiz da cena.
  - javafx.scene.Scene: A classe para definir a cena da interface gráfica.
  - javafx.stage.Stage: Representa a janela principal da aplicação.
  - java.sql.SQLException: Para capturar exceções SQL, caso haja erros na inicialização do banco.
  - br.com.professorclaytonandrade.sistemaservicojavafx.config.versoesbasedados.InicializadorBancoDados: Classe que será responsável por inicializar e migrar o banco de dados.

package br.com.professorclaytonandrade.sistemaservicojavafx;
import br.com.professorclaytonandrade.sistemaservicojavafx.config.versoesbasedados.InicializadorBancoDados;
import javafx.application.Application;
import javafx.fxml.FXMLLoader;
import javafx.scene.Parent;
import javafx.scene.Scene;
import javafx.stage.Stage;
import java.io.IOException;
import java.sql.SQLException;

2. Definição da Classe StartApplication:
- Herdando de Application:
  A classe StartApplication estende Application, o que significa que segue o ciclo de vida de uma aplicação JavaFX. O método start é obrigatório e será executado ao iniciar a aplicação.
- Método start(Stage stage):
  - O método é responsável por configurar a interface gráfica e exibir a janela principal.
  - Carregando o FXML:
    Usa o FXMLLoader para carregar o arquivo start-view.fxml, que define o layout da interface da aplicação.
  - Criando a Cena:
    A cena é criada e vinculada ao estágio, que é a janela principal.
  - Maximizando a Janela:
    A janela é maximizada usando o método stage.setMaximized(true).
  - Definindo o Título:
    O título da janela é configurado para “Sistema de Serviços JavaFX”.
  - Exibindo a Janela:
    Finalmente, a janela é exibida com stage.show().

public class StartApplication extends Application {
    @Override
    public void start(Stage stage) throws IOException {
        Parent parent = FXMLLoader.load(StartApplication.class.getResource("start-view.fxml"));
        Scene scene = new Scene(parent);
        stage.setMaximized(true);
        stage.setTitle("Sistema de Serviços JavaFX");
        stage.setScene(scene);
        stage.show();
    }
}

3. Método main(String[] args):
- Inicialização do Banco de Dados:
  A instância de InicializadorBancoDados é criada, e o método inicializar() é chamado. Esse método será responsável por inicializar o banco de dados e aplicar migrações necessárias.
  - Nota: O método inicializar() será implementado posteriormente para realizar tarefas como criação de tabelas, inserção de dados iniciais, ou atualização de esquemas do banco de dados.
- Iniciando a Aplicação JavaFX:
  Após a inicialização do banco de dados, o método launch() é chamado. Esse método inicia a aplicação JavaFX e executa o método start.

public static void main(String[] args) throws SQLException {
    InicializadorBancoDados inicializadorBancoDados = new InicializadorBancoDados();
    inicializadorBancoDados.inicializar();
    launch();
}

Resumo
A classe StartApplication é a porta de entrada para a aplicação JavaFX. Ela:
- Carrega a interface de usuário a partir de um arquivo FXML.
- Configura a janela principal da aplicação.
- Inicia o banco de dados e aplica migrações, caso necessário, antes de exibir a interface gráfica.
- O banco de dados será inicializado através da classe InicializadorBancoDados, que, em uma implementação futura, será responsável por garantir que as migrações sejam aplicadas corretamente.

Implementação Posterior
- O método responsável por inicializar o banco de dados será implementado futuramente para garantir que o sistema possa gerenciar suas versões de forma adequada. Isso permite flexibilidade e controle sobre mudanças de estrutura no banco de dados.