DEV Community: Anderson Santana

SOLID (Parte 2) - Single Responsibility Principle (SRP)

Anderson Santana — Thu, 19 Jan 2023 13:52:03 +0000

O princípio de Responsabilidade Única (SRP, do inglês Single Responsibility Principle) diz que cada classe ou módulo deve ter apenas uma responsabilidade, veja o código abaixo.


public class OrderService {

    private OrderRepository orderRepository;
    private InventoryService inventoryService;

    public OrderService(OrderRepository orderRepository, InventoryService inventoryService) {
        this.orderRepository = orderRepository;
        this.inventoryService = inventoryService;
    }

    public Order createOrder(Order order) {
        // Salva a ordem no banco de dados
        orderRepository.save(order);
        // Atualiza o estoque
        inventoryService.updateInventory(order.getItems());
        // Calcula o preço total da ordem
        order.setTotalPrice(calculateTotalPrice(order.getItems()));
        // Envia um e-mail de confirmação para o cliente
        sendConfirmationEmail(order.getCustomer().getEmail());
    }

    private void sendConfirmationEmail(String email) {
        // Código para enviar o e-mail
    }

    private double calculateTotalPrice(List<Item> items) {
        // Código para calcular o preço total
    }
}

Neste exemplo, a classe OrderService tem quatro responsabilidades diferentes: salvar a ordem no banco de dados, atualizar o estoque, calcular o preço total da ordem e enviar um e-mail de confirmação para o cliente. Isso viola o SRP pois a classe estaria realizando múltiplas tarefas, essa classe poderia ser dividida em outras classes cada uma com sua responsabilidade específica.

Abaixo você pode ver um exemplo de como isso pode ser feito:

public class CreateOrderGatewayImp implements CreateOrderGateway{

    private OrderRepository orderRepository;

    public CreateOrderService(OrderRepository orderRepository) {
        this.orderRepository = orderRepository;
    }

    public Order execute(Order order) {
        return orderRepository.save(order);
    }

Note que eu estou retornando a ordem que foi salva e a mesma geralmento volta com um id que é gerado pelo banco de dados, essas informações podem ser usadas como fontes de dados para execução de métodos em outras classes que estejam no fluxo.

Talvez você possa estar se perguntando o motivo dessa classe ser uma implementação, vou falar mais sobre isso em outro artigo.

Princípio de agregação de responsabilidade

Mas em algum momento precisarei chamar os métodos das classes que forem implementadas, quando isso vai acontecer?

Você tem razão, em algum momento pode ser necessário chamar esses métodos em sequência, como no exemplo que eu dei na primeira impementação, onde é necessário salvar a ordem no banco de dados antes de atualizar o estoque, e calcular o preço total antes de enviar o e-mail de confirmação.

Uma maneira de lidar com isso é usar o princípio de agregação de responsabilidade, esse princípio não faz parte dos princípios do SOLID diretamente, no entanto, ele é frequentemente usado como uma técnica para aplicar o princípio de Responsabilidade Única (SRP).Isso significa que, em vez de ter uma única classe responsável por todas as tarefas relacionadas à criação de uma ordem, você pode ter várias classes, cada uma responsável por uma tarefa específica e, em seguida, agregá-las para formar uma classe intermediária que chama essas classes de forma sequencial.

Por exemplo, você pode criar uma classe OrderCreatorService que tem como responsabilidade única criar uma ordem e chama as classes CreateOrderGateway, InventoryUpdater, PriceCalculator e ConfirmationEmailSender, e assim por diante, cada uma dessas classes tem sua responsabilidade específica.

public class CreateOrderService {
    private CreateOrderGateway CreateOrderGateway;
    private InventoryUpdaterService inventoryUpdaterService;
    private PriceCalculatorService priceCalculatorService;
    private ConfirmationEmailSenderService confirmationEmailSenderService;

    public OrderCreator(CreateOrderGateway CreateOrderGateway, InventoryUpdaterService inventoryUpdaterService, PriceCalculatorService priceCalculatorService, ConfirmationEmailSenderService confirmationEmailSenderService) {
        this.CreateOrderGateway = CreateOrderGateway;
        this.inventoryUpdaterService = inventoryUpdaterService;
        this.priceCalculatorService = priceCalculatorService;
        this.confirmationEmailSenderService = confirmationEmailSenderService;
    }

    public void execute(Order order) {
        Order savedOrder = CreateOrderGateway.execute(order);
        inventoryUpdaterService.execute(savedOrder.getItems());
        savedOrder.setTotalPrice(priceCalculatorService.execute(savedOrder.getItems()));
        confirmationEmailSenderService.execute(savedOrder.getCustomer().getEmail());
    }
}

Vamos ficando por aqui, qualque dúvida ficarei feliz em responder.

(continua)

SOLID (Parte 1)

Anderson Santana — Thu, 19 Jan 2023 03:32:10 +0000

SOLID é um acrônimo para os cinco princípios de projeto de software desenvolvidos por Robert C. Martin, conhecidos como "os princípios SOLID de programação orientada a objetos".

Introdução

Single Responsibility Principle (SRP) - Um módulo ou classe deve ter uma única responsabilidade, ou seja, deve ser responsável por uma única parte da funcionalidade do sistema. Isso significa que cada classe ou módulo deve ser projetado para realizar uma tarefa específica e não deve ter responsabilidades adicionais. Isso garante que o código seja mais fácil de manter e entender, pois cada classe tem uma única razão para mudar.
Open-Closed Principle (OCP) - Um módulo ou classe deve estar aberto para extensão, mas fechado para modificação. Isso significa que ele deve ser projetado de forma a permitir a adição de novas funcionalidades sem alterar o código existente. Isso pode ser alcançado através da herança ou da implementação de interfaces, permitindo que novas classes possam ser adicionadas sem afetar as classes existentes. Isso garante que o código seja escalável e fácil de manter.
Liskov Substitution Principle (LSP) - As classes derivadas devem ser substituíveis pelas classes base. Isso significa que se uma classe pode ser usada no lugar de outra, elas devem ter uma relação de herança. Isso garante que as classes derivadas possam ser usadas de forma intercambiável com as classes base, sem afetar o comportamento do sistema.
Interface Segregation Principle (ISP) - Não se deve forçar clientes a implementar interfaces que eles não usam. As interfaces devem ser específicas para as necessidades de cada cliente. Isso significa que as interfaces devem ser divididas em interfaces menores e mais específicas, ao invés de uma única interface grande, para garantir que os clientes não sejam forçados a implementar métodos que eles não precisam.
Dependency Inversion Principle (DIP) - Os módulos de alto nível não devem depender de módulos de baixo nível; ambos devem depender de abstrações. Isso significa que o código deve ser projetado de forma a depender de interfaces ou abstrações, em vez de classes concretas. Isso garante que as classes de alto nível não sejam dependentes de classes de baixo nível, permitindo que as classes de alto nível não sejam dependentes de classes de baixo nível, permitindo que as classes de alto nível possam ser facilmente testadas e reutilizadas sem afetar as classes de baixo nível. Isso também permite que as classes de baixo nível possam ser facilmente substituídas ou atualizadas sem afetar as classes de alto nível. Isso ajuda a manter o código escalável e fácil de manter.

No próximo artigo vamos colocar a mão na massa e visualizar tudo que foi escrito até aqui no código

O que um desenvolvedor precisa saber para lidar com o estresse no dia a dia.

Anderson Santana — Thu, 19 Jan 2023 03:10:40 +0000

O estresse é uma realidade para muitos profissionais, especialmente para os desenvolvedores de software que lidam com problemas complexos e prazos apertados. Um aspecto importante na compreensão do estresse é entender como ele afeta o cérebro e, em particular, como afeta a área pré-frontal. Este artigo explicará o que é a área pré-frontal, como ela é afetada pelo estresse e como isso afeta os desenvolvedores de software.

O que é o córtex pré-Frontal?

A área pré-frontal é uma região do cérebro humano localizada na frente da região frontal. Ela desempenha um papel importante na regulação de comportamentos complexos, como planejamento, tomada de decisão, controle emocional e capacidade de julgamento. Ela também é importante para a memória de trabalho, a capacidade de se concentrar e para regular a atenção.

Uma das histórias mais famosas relacionadas à área pré-frontal é a do homem chamado Phineas Gage. Em 1848, Gage sofreu um acidente no qual um ferro de 1,25 metros de comprimento, largo como uma mão e pesando cerca de 6,8 kg, atravessou a parte frontal de seu crânio, penetrando na área pré-frontal. Incrivelmente, ele sobreviveu, mas sua personalidade e comportamento mudaram drasticamente. Antes do acidente, ele era considerado um homem trabalhador, honesto e responsável, mas depois do acidente ele tornou-se impulsivo, irresponsável e incapaz de manter um emprego ou relacionamento. Isso levou os cientistas a acreditar que a área pré-frontal desempenha um papel crucial na regulação de comportamentos sociais e emocionais.

O que acontece com o córtex pre frontal quando estamos expostos a muito estresse?

Quando estamos expostos a muito estresse, a área pré-frontal pode ser afetada de várias maneiras. Estudos mostram que o estresse crônico pode levar à redução do volume cerebral na área pré-frontal, bem como à diminuição da atividade neural nessa região. Além disso, o estresse também pode afetar a capacidade da área pré-frontal de regular emoções e comportamentos, o que pode contribuir para problemas de saúde mental, como ansiedade e depressão.

Em que isso me afeta como desenvolvedor de software?

A área pré-frontal é crucial para o desenvolvimento de software, pois é responsável por planejar e organizar o trabalho, desde a definição dos requisitos até a implementação e testes. Ela também é importante para tomar decisões eficazes e lidar com problemas e imprevistos durante o processo de desenvolvimento. Além disso, a área pré-frontal é essencial para controlar emoções e lidar com o estresse durante o desenvolvimento de software, especialmente quando as coisas não saem como planejadas, ou seja, um pouco de estresse pode fazer você entrar em um loop de situações negativas.

Como posso diminuir o estresse e aumentar o desempenho do cérebro?

Existem várias maneiras de diminuir o estresse e aumentar o desempenho da área pré-frontal:

Prática de meditação e técnicas de relaxamento: a meditação e outras técnicas de relaxamento, como a respiração profunda e a yoga, podem ajudar a reduzir o estresse e aumentar a atividade no córtex pré-frontal.
Exercício regular: O exercício regular pode ajudar a aliviar o estresse e melhorar a função do córtex pré-frontal, pois aumenta a circulação sanguínea e oxigenação do cérebro.
Boa noite de sono: Obter uma boa noite de sono é importante para a saúde geral e pode ajudar a reduzir o estresse e aumentar a função do córtex pré-frontal.
Alimentação saudável: Consumir uma dieta equilibrada e rica em nutrientes, como frutas, vegetais, proteínas e gorduras saudáveis, pode ajudar a melhorar a saúde do cérebro e reduzir o estresse.
Redução do uso de álcool e tabaco: O uso excessivo de álcool e tabaco pode afetar negativamente a saúde do cérebro e aumentar o estresse, portanto, é importante reduzir ou evitar esses hábitos.
Socializar-se: Manter relações sociais saudáveis e interagir com outras pessoas pode ajudar a reduzir o estresse e aumentar a função do córtex pré-frontal.

Além disso, é importante estabelecer limites saudáveis no trabalho, desconectar-se regularmente e buscar ajuda se necessário. Ao cuidar da saúde mental e do bem-estar, os desenvolvedores podem melhorar sua capacidade de lidar com o estresse e manter a área pré-frontal saudável e funcionando corretamente. Como consequência, seu desempenho melhorará substancialmente, tanto no trabalho, como em outras áreas da vida.