DEV Community: NazarioLuis

Implementing jTextField for Swing with Decimal Values and Thousand Separator

NazarioLuis — Mon, 24 Feb 2025 14:01:37 +0000

Introduction

When developing Java Swing applications, handling numeric inputs efficiently is essential, especially when dealing with decimal values and thousand separators. xNumberField is a custom JTextField component that simplifies this process, ensuring accurate input and formatting. This guide will walk you through installing and using xNumberField in your Swing project.

GitHub Repository: xNumberField

Installing xNumberField

If you want to use xNumberField in your Java Swing project with Maven, follow these steps:

1. Add JitPack Repository

In your pom.xml file, add the following repository in the <repositories> section:

<repositories>
    <repository>
        <id>jitpack.io</id>
        <url>https://jitpack.io</url>
    </repository>
</repositories>

2. Add Dependency

Include the following dependency inside the <dependencies> section to use version v1.0.0 of the library:

<dependency>
    <groupId>com.github.NazarioLuis</groupId>
    <artifactId>xNumberField</artifactId>
    <version>LATEST</version>
</dependency>

3. Usage Example

Here is an example of how to use NumberTextField in a Swing application:


// Import the xNumberField component
import py.com.cs.xnumberfield.component;

// Create an instance of NumberTextField
NumberTextField numberTextField = new NumberTextField();

// Set an initial value of 1,000,000
numberTextField.setValue(1000000d);

// Retrieve the current value from the field
Double number = numberTextField.getValue();

Clean Architecture Implementation in NodeJS

NazarioLuis — Tue, 11 Jun 2024 16:12:53 +0000

Clean Architecture is a software architectural approach that emphasizes the separation of concerns and the independence of dependencies within a system. The main idea behind Clean Architecture is to design software systems in a way that allows for easy maintenance, scalability, and testability, while also promoting a clear understanding of the system's structure and behavior.

*Repository: *https://github.com/NazarioLuis/js-clean-architecture/
In a Clean Architecture setup, the system is divided into layers, each with its own specific responsibility. This repository contains a base implementation of Clean Architecture in JavaScript using NodeJS. The code includes three layers of abstraction:

Domain Layer: This is where the models and business rules are implemented via the behavior of the models.
Application Layer: This is where the application logic is implemented according to use cases.
Infrastructure Layer: This is where the persistence strategy is implemented using the models from the domain layer.

Dependencies

awilix
mocha

Utility for Module Import

This utility module provides a function for importing multiple modules dynamically from a directory

util/import-modules.js

const fs = require('fs');
const path = require('path');

module.exports = function (filename, dirname) {
    const imports = [];
    const basename = path.basename(filename);
    fs.readdirSync(dirname)
        .filter(file => (file.indexOf('.') !== 0) && (file !== basename) && (file.slice(-3) === '.js'))
        .forEach(file => {
            const mod = require(path.join(dirname, file));
            imports.push(mod);
        });
    return imports;
};

Domain Layer

Helper

This module contains helper functions commonly used across the domain layer, such as a function to check for required parameters and a function to throw an error for unimplemented methods.

domain/helper.js

const REQUIRED = (attr) => {
    if (attr === undefined) throw new Error('ERR_REQUIRED_PARAM');
    return attr;
};

const NON_IMPLEMENTED = () => {
    throw new Error('ERR_METHOD_NOT_IMPLEMENTED');
};

module.exports = { REQUIRED, NON_IMPLEMENTED };

Models

This module defines the User model class, representing a user entity with attributes such as id, firstname, lastname, etc.

domain/models/user.model.js

const { REQUIRED } = require('../helper');

class User {
    constructor({ id = 0, firstname, lastname, nick, pass, createdAt, updatedAt }) {
        this.id = id;
        this.firstname = REQUIRED(firstname);
        this.lastname = REQUIRED(lastname);
        this.nick = REQUIRED(nick);
        this.pass = pass;
        this.createdAt = createdAt;
        this.updatedAt = updatedAt;
    }
}

module.exports = User;

Behavior

This module defines the behavior interface for user-related operations such as getAll, get, create, update, and delete. These methods are placeholders and should be implemented by concrete classes.

domain/behavior/user.behavior.js

const { NON_IMPLEMENTED } = require('../helper');

class UserBehavior {
    getAll = () => NON_IMPLEMENTED();
    get = id => NON_IMPLEMENTED();
    create = entity => NON_IMPLEMENTED();
    update = (entity, id) => NON_IMPLEMENTED();
    delete = id => NON_IMPLEMENTED();
}

module.exports = UserBehavior;

Application Layer

User Interactor

This module acts as an intermediary between the application layer and the domain layer, handling user-related use cases. It encapsulates the business logic associated with user operations, such as user creation, retrieval, updating, and deletion.

application/user.interactor.js

const UserBehavior = require('../domain/behavior/user.behavior');
const User = require('../domain/models/user.model');

class UserInteractor extends UserBehavior {
    constructor({ UserRepository }) {
        super();
        this._entityRepo = UserRepository;
    }

    getAll = () => this._entityRepo.getAll();
    get = id => this._entityRepo.get(id);
    create = entity => this._entityRepo.create(new User(entity));
    update = (entity, id) => this._entityRepo.update(new User(entity), id);
    delete = id => this._entityRepo.delete(id);
}

module.exports = UserInteractor;

Application Index

This file dynamically imports all modules from the application layer using the importModules utility function.

application/index.js

const importModules = require('../util/import-modules');
const infrastructureModules = importModules(__filename, __dirname);
module.exports = infrastructureModules;

Infrastructure Layer

User Repository

This module defines the persistence strategy for user entities. It encapsulates data access logic and implements CRUD (Create, Read, Update, Delete) operations on user data.

infrastructure/repositories/user.repository.js

const UserBehavior = require('../../domain/behavior/user.behavior');

class UserRepository extends UserBehavior {
    users = [
        { id: 1, firstname: "Eddard", lastname: "Stark", nick: "ned", pass: "123" },
        { id: 2, firstname: "Catelyn", lastname: "Tully", nick: "cat", pass: "123" }
    ];

    getAll = () => this.users;
    get = id => this.users.find(x => x.id == id);
    create = entity => {
        const newUser = { ...entity, id: this.users[this.users.length - 1].id + 1 };
        this.users.push(newUser);
        return newUser;
    };
    update = (entity, id) => {
        const index = this.users.findIndex(x => x.id == id);
        this.users[index] = { ...entity, id: this.users[index].id };
        return this.users[index];
    };
    delete = id => {
        const index = this.users.findIndex(x => x.id == id);
        this.users.splice(index, 1);
        return id;
    };
}

module.exports = UserRepository;

Repository Index

This file dynamically imports all modules from the repository layer using the importModules utility function.

infrastructure/repositories/index.js

const importModules = require('../../util/import-modules');
const infrastructureModules = importModules(__filename, __dirname);
module.exports = infrastructureModules;

Dependency Injection Container

Container

This module configures a dependency injection container using Awilix. It registers application and repository modules as dependencies, facilitating dependency injection across the application.

container.js

const awilix = require('awilix');
const applicationModules = require('./application');
const infrastructureModules = require('./infrastructure/repositories');

const modules = [
    ...applicationModules,
    ...infrastructureModules,
];

const container = awilix.createContainer();

const resolvers = {};
modules.forEach(module => {
    if (module.toString().substring(0, 5) === 'class') {
        resolvers[module.name] = awilix.asClass(module).singleton();
    } else {
        resolvers[module.name] = awilix.asFunction(module).singleton();
    }
});

container.register(resolvers);

module.exports = container;

Testing

This module contains test cases for the user-related functionality implemented in the application layer. It uses the Mocha framework for test execution and assertion.

User Tests

test/user.test.js

var assert = require('assert');
const interactor = require('../container').cradle.UserInteractor;

describe("User", function () {
    describe("CRUD operations", function () {
        it("create", function () {
            const result = interactor.create({
                firstname: "John",
                lastname: "Snow",
                nick: "snow",
                pass: "123",
            });
            assert.strictEqual(result.id > 0, true);
        });

        it("get all", function () {
            const result = interactor.getAll();
            assert.strictEqual(result.length > 0, true);
        });

        it("get", function () {
            const result = interactor.get(1);
            assert.strictEqual(result == null, false);
        });

        it("update", function () {
            const result = interactor.update({
                firstname: "Sansa",
                lastname: "Stark",
                nick: "sansa",
                pass: "123",
            }, 1);
            const aux = interactor.get(1);
            assert.strictEqual(result.firstname, aux.firstname);
        });

        it("delete", function () {
            const deletedId = interactor.delete(1);
            const result = interactor.get(deletedId);
            assert.strictEqual(result == null, true);
        });
    });
});

This implementation covers the basic structure and flow of Clean Architecture in NodeJS, focusing on separation of concerns and modularity. The provided code includes models, behaviors, repositories, and tests to demonstrate how each layer interacts with one another.

Hibernate Connection Library with GUI Generation

NazarioLuis — Tue, 11 Jun 2024 14:59:53 +0000

This library streamlines Java application development by effortlessly generating graphical interfaces from defined entity classes. It seamlessly integrates with the Hibernate framework to provide database connectivity, with a primary focus on creating intuitive interfaces for managing database entities.
Repository: https://github.com/NazarioLuis/AutoCRUD/

1. Adding the Library with JitPack

To add the AutoCRUD library to your project using JitPack, follow these steps:

Add the JitPack repository to your pom.xml:

<repositories>
    <repository>
        <id>jitpack.io</id>
        <url>https://jitpack.io</url>
    </repository>
</repositories>

Add the AutoCRUD dependency to your pom.xml:

<properties>
    <AutoCRUD-version>LATEST</AutoCRUD-version>
</properties>

<dependencies>
    <dependency>
        <groupId>com.github.NazarioLuis</groupId>
        <artifactId>AutoCRUD</artifactId>
        <version>${AutoCRUD-version}</version>
    </dependency>
</dependencies>

Replace LATEST with the latest version available if you want to specify a version, for example v1.0.0.

2. Hibernate configuration

To configure Hibernate for your project, create a hibernate.properties file and add the following settings:

hibernate.connection.url=jdbc:postgresql://localhost:5432/database
hibernate.connection.driver_class=org.postgresql.Driver
hibernate.connection.username=postgres
hibernate.connection.password=123
hibernate.current_session_context_class=thread
hibernate.show_sql=true
hibernate.hbm2ddl.auto=update
mapping_packages=package_name.entities

The mapping_packages configuration in Hibernate setup serves to specify the packages that Hibernate should scan for entity classes. When Hibernate initializes its persistence environment, it needs to know which classes represent entities in the database to map them correctly.

mapping_packages=com.example.package1.entities, com.example.package2.entities

In this configuration, Hibernate will scan both com.example.package1.entities and com.example.package2.entities packages for entity classes. Any Java class annotated with @Entity and residing in either of these packages will be considered an entity and mapped accordingly to the database tables.

3. Definition of Entity Classes

To utilize the graphical interface generation functionality, define your entity classes representing tables in your database. Annotations can be applied to these classes and their fields to customize the behavior and appearance of the generated interfaces.

Here's an example using the "Customer" entity:

import java.util.Date;
import jakarta.persistence.Entity;
import jakarta.persistence.Id;
import py.nl.AutoCrud.annotations.HiddenInput;
import py.nl.AutoCrud.annotations.Input;
import py.nl.AutoCrud.annotations.RequiredInput;
import py.nl.AutoCrud.annotations.EntityCRUD;
import py.nl.AutoCrud.annotations.Relationship;

@Entity
@EntityCRUD(
    title = "Customer CRUD",
    formTitle = "Customer personal data",
    columnCount = 2,
    width = 80,
    height = 80
)
public class Customer {
    @Id
    private int id;

    @RequiredInput
    @Input(tableColumn = true)
    private String name;

    @RequiredInput
    @Input(tableColumn = true)
    private String lastName;

    @RequiredInput
    @Input(tableColumn = true)
    private String document;

    private String phone;

    private String address;

    @HiddenInput
    @Input(tableColumn = true)
    private Date registrationDate;

    @Input(tableColumn = true)
    private boolean active;

    @RequiredInput
    @ManyToOne
    @Relationship(displayInForm = ":name") // Add the relationship with City
    private City city; // Define the relationship with City

    public Customer() {
        // Set default values for fields
        registrationDate = new Date();
        active = true;
    }

    // Getters and setters omitted for brevity
}

Here we've added the @ManyToOne relationship with City in the Customer class, along with the @Relationship annotation to customize how this relationship is displayed in the generated form.

Definition of the `City` Entity:

import jakarta.persistence.Entity;
import jakarta.persistence.GeneratedValue;
import jakarta.persistence.Id;
import py.nl.AutoCrud.annotations.Input;
import py.nl.AutoCrud.annotations.RequiredInput;
import py.nl.AutoCrud.annotations.EntityCRUD;

@Entity
@EntityCRUD(
    title = "City CRUD",
    formTitle = "City information",
    width = 60,
    height = 60
)
public class City {

    @Id
    @GeneratedValue
    private int id;

    @RequiredInput
    @Input(tableColumn = true)
    private String name;

    public City() {
    }

    // Getters and setters omitted for brevity
}

4. Explanation of Annotations

`@EntityCRUD`

title: Specifies the title of the CRUD (Create, Read, Update, Delete) interface generated for the entity. It typically appears at the top of the interface, providing a clear indication of what kind of records the interface deals with.
formTitle: Sets the title of the form or dialog used for adding or editing records. It appears as the title of the window or section where users input or modify data.
columnCount: Determines the number of columns used for displaying the form in the CRUD interface. It helps in organizing and presenting form fields more efficiently, especially when dealing with forms with many fields.
width: Specifies the width of the CRUD interface window as a percentage of the screen width. It allows customization of the interface's size to fit different screen resolutions and user preferences.
height: Defines the height of the CRUD interface window as a percentage of the screen height. It enables adjusting the interface's vertical size according to the content and usability requirements.

`@HiddenInput`

This annotation indicates that the annotated field should be hidden in the graphical interface. It's useful for fields that are not meant to be directly visible or editable by users, such as internal identifiers or sensitive information.

`@Input`

label: Specifies the label or prompt displayed alongside the input field in the graphical interface. It provides users with context and guidance on what type of data to input.
data: Used for specifying predefined options for the input field, typically for dropdown lists or combo boxes. It allows users to select from a predefined set of values rather than entering free-form text.
longText: Indicates whether the input field should be displayed as a text area for entering longer text. It's useful for fields that may contain paragraphs or extended descriptions.
tableColumn: Determines whether the annotated field should be displayed as a column in the table view of the graphical interface. It allows customization of which fields are visible in the table, optimizing screen space and focusing on relevant information.

`@RequiredInput`

This annotation marks the annotated field as required in the graphical interface. It ensures that users must provide a value for the field when interacting with the interface, helping to maintain data integrity and completeness.

`@Relationship`

This annotation is used to define relationships between entities in the graphical interface.

displayInForm: Specifies how the relationship is displayed in the form. For example, :lastname, :name can be used to display the lastname and name attributes of the related entity as a string.

5. Usage of GUI Generation

Once you've defined your entity classes and annotated them appropriately, you can use the provided functionality to generate graphical interfaces for CRUD operations. Here's an example of how to create a view for the "Customer" entity:

import py.nl.AutoCrud.AutoCRUD;

public class Main {
    public static void main(String[] args) {
        // Create an instance of AutoCRUD for the Customer class
        AutoCRUD<Customer> crud = new AutoCRUD<>(Customer.class);

        // Show the graphical interface
        crud.setVisible(true);
    }
}

Replace "Customer" with your entity class name, and adjust the package and import statements accordingly. This code snippet creates a GUI interface for performing CRUD operations on the specified entity class.