Uma estrutura de projeto eficaz é crucial para o desenvolvimento Java bem-sucedido. Este guia abrangente explora os princípios fundamentais da organização de projetos Java, fornecendo aos desenvolvedores insights práticos sobre como criar soluções de software escaláveis, sustentáveis e bem estruturadas.
Projetos Java seguem certas convenções organizacionais que ajudam os desenvolvedores a gerenciar o código de forma eficaz. Nesta etapa, você criará manualmente uma estrutura simples de projeto Java para entender os componentes fundamentais.
Um projeto Java normalmente contém:
.java).class)Vamos começar criando uma estrutura básica de projeto em seu ambiente de trabalho. Construiremos uma simples aplicação "HelloWorld" para demonstrar os conceitos.
Primeiro, abra um terminal no seu ambiente LabEx. Seu terminal já deve estar no diretório /home/labex/project.
Crie um diretório de projeto para nossa aplicação Java:
mkdir -p hello-java-app/src
cd hello-java-appsrc, crie um arquivo de classe Java simples:mkdir -p src/com/example/appHelloWorld.java no caminho hello-java-app/src/com/example/app/:package com.example.app;
public class HelloWorld {
public static void main(String[] args) {
System.out.println("Hello, Java Project World!");
}
}cd /home/labex/project/hello-java-app
mkdir -p bin
javac -d bin src/com/example/app/HelloWorld.javaA saída não deve mostrar erros se a compilação foi bem-sucedida.
java -cp bin com.example.app.HelloWorldVocê deve ver a saída:
Hello, Java Project World!Vamos revisar o que criamos:
hello-java-app/
├── bin/ ## Bytecode compilado (arquivos .class)
│ └── com/
│ └── example/
│ └── app/
│ └── HelloWorld.class
└── src/ ## Código fonte (arquivos .java)
└── com/
└── example/
└── app/
└── HelloWorld.javaEsta estrutura segue estes princípios:
srccom.example.app corresponde aos diretórios com/example/app/bin separado-cp diz ao Java onde encontrar as classes compiladasVocê agora criou manualmente uma estrutura básica de projeto Java. Esta base o ajudará a entender estruturas de projeto mais complexas usadas em aplicações do mundo real.
Nesta etapa, você aprenderá como organizar seu código Java usando pacotes e criar uma aplicação mais estruturada com múltiplas classes. A organização adequada de pacotes é essencial para projetos Java sustentáveis.
Os pacotes Java seguem uma convenção de nomenclatura hierárquica:
com.example)com.example.project)com.example.project.model)Vamos implementar esta estrutura em nosso projeto.
Construiremos um sistema simples de gerenciamento de biblioteca com pacotes distintos para diferentes preocupações:
cd /home/labex/project
mkdir -p library-app/src
cd library-appmkdir -p src/com/example/library/model
mkdir -p src/com/example/library/service
mkdir -p src/com/example/library/utilBook.java no caminho library-app/src/com/example/library/model/:package com.example.library.model;
public class Book {
private String title;
private String author;
private int year;
public Book(String title, String author, int year) {
this.title = title;
this.author = author;
this.year = year;
}
// Getters
public String getTitle() {
return title;
}
public String getAuthor() {
return author;
}
public int getYear() {
return year;
}
@Override
public String toString() {
return "Book{title='" + title + "', author='" + author + "', year=" + year + "}";
}
}library-app/src/com/example/library/service/BookService.java:package com.example.library.service;
import com.example.library.model.Book;
import java.util.ArrayList;
import java.util.List;
public class BookService {
private List<Book> books = new ArrayList<>();
public void addBook(Book book) {
books.add(book);
}
public List<Book> getAllBooks() {
return new ArrayList<>(books);
}
public Book findBookByTitle(String title) {
for (Book book : books) {
if (book.getTitle().equalsIgnoreCase(title)) {
return book;
}
}
return null;
}
}library-app/src/com/example/library/util/BookFormatter.java:package com.example.library.util;
import com.example.library.model.Book;
public class BookFormatter {
public static String formatBookInfo(Book book) {
return String.format("'%s' by %s (%d)",
book.getTitle(), book.getAuthor(), book.getYear());
}
}library-app/src/com/example/library/LibraryApp.java:package com.example.library;
import com.example.library.model.Book;
import com.example.library.service.BookService;
import com.example.library.util.BookFormatter;
public class LibraryApp {
public static void main(String[] args) {
// Create service
BookService bookService = new BookService();
// Add some books
bookService.addBook(new Book("The Great Gatsby", "F. Scott Fitzgerald", 1925));
bookService.addBook(new Book("To Kill a Mockingbird", "Harper Lee", 1960));
bookService.addBook(new Book("1984", "George Orwell", 1949));
// Display all books
System.out.println("Library Catalog:");
for (Book book : bookService.getAllBooks()) {
System.out.println(BookFormatter.formatBookInfo(book));
}
// Find a specific book
Book foundBook = bookService.findBookByTitle("1984");
if (foundBook != null) {
System.out.println("\nFound book: " + foundBook);
}
}
}mkdir -p bin
javac -d bin src/com/example/library/model/Book.java src/com/example/library/service/BookService.java src/com/example/library/util/BookFormatter.java src/com/example/library/LibraryApp.javajava -cp bin com.example.library.LibraryAppVocê deve ver a saída:
Library Catalog:
'The Great Gatsby' by F. Scott Fitzgerald (1925)
'To Kill a Mockingbird' by Harper Lee (1960)
'1984' by George Orwell (1949)
Found book: Book{title='1984', author='George Orwell', year=1949}Vamos examinar a estrutura que criamos:
library-app/
├── bin/ ## Bytecode compilado
└── src/ ## Código fonte
└── com/
└── example/
└── library/
├── model/ ## Estruturas de dados
│ └── Book.java
├── service/ ## Lógica de negócios
│ └── BookService.java
├── util/ ## Funções utilitárias
│ └── BookFormatter.java
└── LibraryApp.java ## Aplicação principalEsta estrutura segue importantes princípios de design:
Separação de Preocupações (Separation of Concerns):
model: Contém estruturas de dadosservice: Contém lógica de negóciosutil: Contém funções utilitáriasAgrupamento Lógico: Classes relacionadas são agrupadas no mesmo pacote
Navegação Intuitiva: A estrutura do pacote facilita a localização de funcionalidades específicas
Gerenciamento de Importação: As classes se referenciam através de imports, tornando as dependências claras
Ao organizar o código desta forma, você cria aplicações mais sustentáveis, escaláveis, que são mais fáceis de entender e estender.
Nesta etapa, você aprenderá como usar o Apache Maven para gerenciar seu projeto Java. Maven é uma poderosa ferramenta de automação de construção e gerenciamento de dependências que simplifica a configuração e manutenção do projeto.
Maven fornece:
Vamos criar um novo projeto usando Maven:
mvn --versionVocê deve ver uma saída semelhante a esta:
Apache Maven 3.6.3
Maven home: /usr/share/maven
Java version: 11.0.18, vendor: Ubuntu, runtime: /usr/lib/jvm/java-11-openjdk-amd64
Default locale: en_US, platform encoding: UTF-8
OS name: "linux", version: "5.15.0-1036-azure", arch: "amd64", family: "unix"cd /home/labex/projectmvn archetype:generate \
-DgroupId=com.example.calculator \
-DartifactId=simple-calculator \
-DarchetypeArtifactId=maven-archetype-quickstart \
-DarchetypeVersion=1.4 \
-DinteractiveMode=falseEste comando criará um novo projeto com uma estrutura de diretório padrão.
cd simple-calculator
ls -laVocê deve ver uma saída semelhante a:
total 24
drwxr-xr-x 4 labex labex 4096 ... .
drwxr-xr-x 6 labex labex 4096 ... ..
-rw-r--r-- 1 labex labex 174 ... .gitignore
-rw-r--r-- 1 labex labex 720 ... pom.xml
drwxr-xr-x 4 labex labex 4096 ... srcO arquivo chave aqui é pom.xml (Project Object Model), que define a configuração do projeto.
find src -type dVocê deve ver:
src
src/main
src/main/java
src/main/java/com
src/main/java/com/example
src/main/java/com/example/calculator
src/test
src/test/java
src/test/java/com
src/test/java/com/example
src/test/java/com/example/calculatorEste é o layout de diretório padrão do Maven:
src/main/java: Código fontesrc/main/resources: Arquivos de recursossrc/test/java: Código de testesrc/test/resources: Recursos de testeApp.java gerado:cat src/main/java/com/example/calculator/App.javaVocê deve ver uma classe simples "Hello World":
package com.example.calculator;
/**
* Hello world!
*
*/
public class App
{
public static void main( String[] args )
{
System.out.println( "Hello World!" );
}
}Vamos aprimorar nosso projeto de calculadora adicionando mais classes:
Calculator.java em src/main/java/com/example/calculator/:package com.example.calculator;
public class Calculator {
public int add(int a, int b) {
return a + b;
}
public int subtract(int a, int b) {
return a - b;
}
public int multiply(int a, int b) {
return a * b;
}
public double divide(int a, int b) {
if (b == 0) {
throw new ArithmeticException("Cannot divide by zero");
}
return (double) a / b;
}
}App.java existente para usar nossa classe Calculator:package com.example.calculator;
/**
* Simple Calculator Application
*/
public class App
{
public static void main( String[] args )
{
Calculator calculator = new Calculator();
// Perform some calculations
System.out.println("Addition: 5 + 3 = " + calculator.add(5, 3));
System.out.println("Subtraction: 10 - 4 = " + calculator.subtract(10, 4));
System.out.println("Multiplication: 6 * 7 = " + calculator.multiply(6, 7));
System.out.println("Division: 20 / 4 = " + calculator.divide(20, 4));
System.out.println("Calculator application completed successfully!");
}
}mvn compileVocê deve ver uma saída terminando com:
[INFO] ------------------------------------------------------------------------
[INFO] BUILD SUCCESS
[INFO] ------------------------------------------------------------------------mvn packageEste comando compila seu código, executa testes e empacota a aplicação.
java -cp target/simple-calculator-1.0-SNAPSHOT.jar com.example.calculator.AppVocê deve ver a saída:
Addition: 5 + 3 = 8
Subtraction: 10 - 4 = 6
Multiplication: 6 * 7 = 42
Division: 20 / 4 = 5.0
Calculator application completed successfully!O arquivo Project Object Model (POM) contém a configuração do projeto. Abra o arquivo pom.xml no editor e examine sua estrutura:
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
<modelVersion>4.0.0</modelVersion>
<groupId>com.example.calculator</groupId>
<artifactId>simple-calculator</artifactId>
<version>1.0-SNAPSHOT</version>
<name>simple-calculator</name>
<!-- FIXME change it to the project's website -->
<url>http://www.example.com</url>
<properties>
<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
<maven.compiler.source>1.7</maven.compiler.source>
<maven.compiler.target>1.7</maven.compiler.target>
</properties>
<dependencies>
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<version>4.11</version>
<scope>test</scope>
</dependency>
</dependencies>
<!-- Build configuration... -->
</project>Elementos chave no arquivo POM:
groupId: Identificador da organização ou projetoartifactId: Nome do projetoversion: Versão do projetodependencies: Bibliotecas externas usadas pelo projetobuild: Configuração para construir o projetoAqui estão alguns comandos essenciais do Maven:
mvn compile: Compila o código fontemvn test: Executa testesmvn package: Cria um pacote distribuível (JAR, WAR)mvn install: Instala o pacote no repositório localmvn clean: Remove artefatos de construção (diretório target)mvn clean install: Combinação de clean e installMaven simplificou drasticamente o gerenciamento de projetos Java, fornecendo convenções, gerenciamento de dependências e automação de construção. Essa abordagem padronizada ajuda os desenvolvedores a se concentrarem na escrita de código, em vez de gerenciar a estrutura do projeto.
Neste laboratório, você aprendeu estratégias essenciais para gerenciar a estrutura de projetos Java por meio de prática:
Você começou criando uma estrutura básica de projeto Java manualmente, compreendendo os componentes fundamentais de diretórios de origem, pacotes e organização de código compilado.
Em seguida, você avançou para a criação de um projeto mais complexo com organização de pacotes adequada, implementando a separação de preocupações, dividindo a funcionalidade em pacotes de modelo, serviço e utilidade.
Finalmente, você aprendeu como usar o Maven, uma poderosa ferramenta de automação de construção, para criar e gerenciar projetos Java padronizados com gerenciamento de dependências e processos de construção automatizados.
Essas habilidades fundamentais servirão como uma base sólida para seu futuro trabalho de desenvolvimento Java, permitindo que você crie aplicações bem organizadas, sustentáveis e escaláveis. Ao seguir as convenções estabelecidas e as melhores práticas para a estrutura do projeto, você colaborará de forma mais eficaz com outros desenvolvedores e produzirá código de maior qualidade.
