DEV Community: Dina Essam

Java Multi-threading Gone Wrong: A Real-World Backend Nightmare

Dina Essam — Thu, 27 Mar 2025 20:07:22 +0000

You’ve just deployed your high-performance Spring Boot app. It’s running smoothly—until traffic spikes. Suddenly, everything freezes. No errors, no crashes, just a silent, unresponsive system.

Welcome to deadlock hell—where two threads hold resources hostage, refusing to back down.

How It All Went Wrong

Your backend has two background tasks that update shared resources:

One thread manages database transactions.
Another handles caching to speed up responses.

Seems like a solid architecture, right? But in a high-concurrency scenario, these threads end up waiting on each other, creating an inescapable deadlock.

The Problematic Code:

class Resource {
    private final String name;
    public Resource(String name) { this.name = name; }
    public String getName() { return name; }
}

class DeadlockExample {
    private final Resource resource1 = new Resource("Database Connection");
    private final Resource resource2 = new Resource("Cache Layer");

    public void processA() {
        synchronized (resource1) {
            System.out.println(Thread.currentThread().getName() + " locked " + resource1.getName());
            try { Thread.sleep(100); } catch (InterruptedException ignored) {}
            synchronized (resource2) {
                System.out.println(Thread.currentThread().getName() + " locked " + resource2.getName());
            }
        }
    }

    public void processB() {
        synchronized (resource2) {
            System.out.println(Thread.currentThread().getName() + " locked " + resource2.getName());
            try { Thread.sleep(100); } catch (InterruptedException ignored) {}
            synchronized (resource1) {
                System.out.println(Thread.currentThread().getName() + " locked " + resource1.getName());
            }
        }
    }
}

public class DeadlockSimulator {
    public static void main(String[] args) {
        DeadlockExample system = new DeadlockExample();
        Thread t1 = new Thread(system::processA, "Thread-A");
        Thread t2 = new Thread(system::processB, "Thread-B");
        t1.start();
        t2.start();
    }
}

Why Your Backend Froze

Thread-A locks the Database Connection and waits for the Cache Layer.
Thread-B locks the Cache Layer and waits for the Database Connection.
Neither thread can proceed.
Your backend grinds to a halt.

The Fix: Smarter Locking

Option 1: Consistent Locking Order

Always acquire locks in the same order across all threads.

public void safeProcess() {
    synchronized (resource1) {  // Always lock DB first
        System.out.println(Thread.currentThread().getName() + " locked " + resource1.getName());
        try { Thread.sleep(100); } catch (InterruptedException ignored) {}
        synchronized (resource2) {  // Then lock Cache
            System.out.println(Thread.currentThread().getName() + " locked " + resource2.getName());
        }
    }
}

Now, no matter how many threads you spawn, they won’t get stuck waiting for each other.

Option 2: Use `tryLock()` to Avoid Deadlocks

Instead of waiting indefinitely, use ReentrantLock.tryLock() so a thread can move on if a resource is unavailable.

import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

class SafeResource {
    private final Lock lock = new ReentrantLock();

    public boolean tryLock() {
        return lock.tryLock();
    }

    public void unlock() {
        lock.unlock();
    }
}

Now, if a thread can’t get a lock, it backs off instead of freezing your system.

Final Thoughts: Taming Multi-threading

Multi-threading is powerful, but without careful handling, it’s like playing with dynamite. Avoid deadlocks by:
✅ Always locking resources in the same order

✅ Using tryLock() to prevent indefinite waiting

✅ Monitoring thread activity with tools

Next time your backend locks up, you’ll know exactly where to look. 🚀

The Impact of Capitalism on Human Mental Health: Unveiling the Toll on Well-being

Dina Essam — Tue, 27 Feb 2024 19:00:00 +0000

Welcome, dear readers! Today, we delve into the profound influence of capitalism on human mental health, uncovering how the relentless pursuit of profit often comes at the expense of individual well-being. Through this exploration, we'll illuminate the ways in which capitalism can exacerbate mental health challenges and contribute to the erosion of our collective mental well-being.

Understanding Capitalism's Influence

Commodification of Human Experience

In a capitalist society, everything, including human experiences and emotions, becomes commodified and monetized. Our worth is often measured by our productivity and economic output, leading to a culture of relentless competition and comparison.

Example:

Sara feels pressured to constantly achieve more in her career to maintain her status and financial stability. The constant pursuit of success leaves her feeling exhausted and anxious, contributing to her declining mental health.

Exploitative Labor Practices

Capitalism thrives on exploitative labor practices that prioritize profit over the well-being of workers. Long hours, low wages, and precarious employment conditions can lead to chronic stress, burnout, and feelings of insecurity among employees.

Example:

Ahmed works multiple jobs to make ends meet, often sacrificing his physical and mental health in the process. Despite his efforts, he struggles to keep up with the demands of his work and experiences constant anxiety about his financial future.

Growing Economic Inequality

Capitalism perpetuates economic inequality, widening the gap between the rich and the poor. This disparity in wealth distribution can lead to feelings of inadequacy, resentment, and despair among marginalized communities.

Example:

Fatima, living in a low-income neighborhood, feels trapped in a cycle of poverty with limited access to resources and opportunities for upward mobility. The constant struggle to make ends meet takes a toll on her mental health, leading to feelings of hopelessness and despair.

The Toll on Mental Health

Stress and Anxiety

The constant pressure to succeed in a competitive capitalist society can result in high levels of stress and anxiety. Individuals may feel overwhelmed by the demands of work, finances, and social expectations, leading to mental health issues.

Depression and Burnout

The relentless pursuit of profit often leads to overwork and burnout, contributing to the prevalence of depression and other mood disorders. The inability to escape from the cycle of work and consumption can leave individuals feeling disillusioned and emotionally exhausted.

Alienation and Isolation

Capitalism fosters a culture of individualism and self-interest, leading to social alienation and feelings of isolation. The focus on personal gain can erode social connections and diminish support networks, exacerbating feelings of loneliness and disconnection.

Navigating Towards Well-being

Building Supportive Communities

In the face of capitalist pressures, cultivating supportive communities can provide a sense of belonging and solidarity. By coming together to share experiences, resources, and support, individuals can mitigate the negative impact of capitalism on their mental health.

Advocating for Systemic Change

Addressing the root causes of mental health challenges requires systemic change. Advocating for policies that prioritize worker rights, social safety nets, and equitable access to resources is essential for creating a more just and compassionate society.

Prioritizing Self-care

In the midst of capitalist pressures, prioritizing self-care and mental well-being is crucial. Taking time for rest, relaxation, and activities that bring joy and fulfillment can help individuals cope with the stress and uncertainty of living in a capitalist society.

Conclusion: Towards a More Compassionate Future

In conclusion, capitalism's relentless pursuit of profit often comes at a significant cost to human mental health and well-being. By recognizing the ways in which capitalism exacerbates mental health challenges and advocating for systemic change, we can work towards creating a more compassionate and equitable society for all.

Let's envision a future where human well-being is prioritized over profit, where individuals are valued for their intrinsic worth rather than their economic productivity, and where collective care and support prevail over individualistic pursuits.

Here's to a future where mental health is treated as a fundamental human right, not a luxury afforded only to the privileged few.

Bridging the Gap: Aligning University Education with the Tech Job Market

Dina Essam — Tue, 27 Feb 2024 07:30:00 +0000

Welcome, dear readers! Today, we explore the persistent gap between what students learn at university and the skills demanded by the labor market in the tech field. While higher education aims to equip students with theoretical knowledge and critical thinking skills, employers often prioritize practical, job-specific competencies. Let's delve into this disparity and discuss strategies for narrowing the divide.

Understanding the Discrepancy

Theoretical vs. Practical Learning

University curricula in the tech field typically emphasize theoretical concepts, fundamental principles, and academic research. While this foundation is valuable, it may not directly translate into the hands-on skills and practical experience sought by employers.

Example:

Ali, a recent computer science graduate, excelled in theoretical courses on algorithms and data structures. However, he struggled to apply this knowledge to real-world coding challenges during job interviews, highlighting a gap between academic learning and practical skills.

Evolving Industry Demands

The rapid pace of technological advancement requires professionals to adapt quickly to new tools, frameworks, and methodologies. However, university programs may lag behind industry trends, leading to a disconnect between graduates' skill sets and employers' expectations.

Example:

Sara, a software engineering student, learned outdated programming languages and development methodologies in her university courses. Upon entering the job market, she found herself ill-prepared to work with modern tech stacks and agile development practices, hindering her employability.

Bridging the Divide

Industry-Academia Collaboration

Fostering collaboration between universities and industry partners is essential for aligning educational programs with the demands of the job market. Guest lectures, internships, and industry-sponsored projects can provide students with hands-on experience and exposure to real-world challenges.

Practical Skill Development

Integrating practical skill development into university curricula can better prepare students for the realities of the workplace. Project-based learning, hackathons, and coding bootcamps offer opportunities for students to apply theoretical knowledge in practical contexts and build job-relevant competencies.

Lifelong Learning Mindset

Encouraging students to adopt a lifelong learning mindset is crucial for staying abreast of industry trends and advancing their careers. Continuous professional development, online courses, and participation in tech communities enable graduates to continually update their skills and remain competitive in the job market.

Conclusion: Navigating the Path Forward

In conclusion, bridging the gap between university education and the tech job market requires collaborative efforts from academia, industry, and students themselves. By aligning educational programs with industry demands, fostering practical skill development, and promoting a culture of lifelong learning, we can empower graduates to thrive in the ever-changing tech industry.

Let's work together to ensure that students graduate not only with theoretical knowledge but also with the practical skills and adaptive mindset needed to succeed in today's dynamic job market.

Here's to closing the gap and preparing the next generation of tech professionals for success!

The Impact of Lifelong Learning in the Tech Field on Human Mental Health: Balancing Progress with Well-being

Dina Essam — Tue, 27 Feb 2024 02:16:54 +0000

Welcome, dear readers! Today, we embark on a journey to explore the intricate interplay between lifelong learning in the tech field, human mental health, and the pervasive influence of capitalism. While the pursuit of knowledge is essential for progress, we'll examine how the relentless demands of capitalism can exacerbate mental health challenges and erode well-being. Let's navigate this complex terrain together.

Lifelong Learning in the Tech Field: A Double-Edged Sword

Empowering Innovation and Growth

Lifelong learning in the tech field empowers individuals with new skills, fosters innovation, and drives economic growth. In a world where technological advancements shape our daily lives, staying abreast of the latest developments is crucial for personal and professional success.

Example:

Ahmed, a software developer, regularly attends coding bootcamps and online courses to enhance her programming skills. Her dedication to lifelong learning has enabled her to stay competitive in the ever-evolving tech industry and secure rewarding job opportunities.

The Pressure to Perform

However, the rapid pace of technological change fueled by capitalist ideals often comes with a price. The pressure to constantly upskill, innovate, and compete in the tech industry can lead to stress, anxiety, and burnout among individuals striving to keep pace with the demands of a competitive market.

Example:

Aisha, a data scientist, feels overwhelmed by the constant pressure to learn new machine learning algorithms and programming languages to stay relevant in his field. Despite his passion for data analysis, the relentless pursuit of knowledge has taken a toll on his mental well-being, leading to increased stress and anxiety.

The Toll on Mental Health: Capitalism's Influence

Commodification of Knowledge

In a capitalist society, knowledge is often commodified and valued primarily for its economic utility. Lifelong learning becomes less about personal growth and more about staying employable in a competitive job market. This commodification of knowledge can diminish the intrinsic joy of learning and contribute to feelings of inadequacy and insecurity.

Example:

Sarah, a UX designer, feels pressured to acquire new design skills and certifications to advance her career. While she enjoys learning about user experience principles, the constant emphasis on marketable skills and industry trends leaves her feeling drained and disenchanted with her profession.

Precarity and Insecurity

The gig economy and precarious employment practices prevalent in the tech industry exacerbate feelings of insecurity and instability. Freelancers and contract workers may face unpredictable workloads, income fluctuations, and a lack of job security, leading to chronic stress and anxiety about the future.

Example:

Youssef, a freelance web developer, struggles to make ends meet as he navigates the uncertainty of contract work and irregular income. Despite his passion for coding, the constant financial insecurity and fear of unemployment weigh heavily on his mental well-being, affecting his overall quality of life.

Hyper-Competitive Culture

Capitalism fosters a hyper-competitive culture in which individuals are constantly compared to their peers based on productivity, innovation, and market success. This culture of comparison can fuel imposter syndrome, self-doubt, and mental health issues as individuals strive to meet unrealistic standards and expectations.

Example:

Layla, a young entrepreneur, feels immense pressure to launch a successful startup and achieve rapid growth to attract investors and secure funding. Despite her entrepreneurial spirit and ambition, the intense competition and fear of failure have taken a toll on her mental health, leading to feelings of inadequacy and self-doubt.

Navigating the Intersection: Striving for Balance and Well-being

Prioritizing Self-care and Boundaries

Amidst the demands of lifelong learning and capitalist pressures, prioritizing self-care and setting boundaries is essential for safeguarding mental health. Taking regular breaks, disconnecting from work, and seeking support from friends and loved ones can help individuals maintain balance and resilience in the face of adversity.

Example:

Mohamed, a software engineer, prioritizes his mental well-being by setting strict boundaries around his work hours and taking regular breaks to recharge. By cultivating a healthy work-life balance and prioritizing self-care activities such as exercise and meditation, he has been able to manage stress and maintain his productivity.

Advocating for Systemic Change

Addressing the root causes of mental health challenges requires systemic change. Advocating for policies that promote worker rights, job security, and equitable access to education and healthcare is essential for creating a more just and compassionate society that prioritizes well-being over profit.

Example:

Tech for Good, a grassroots organization advocating for ethical practices in the tech industry, lobbies for policies that prioritize worker well-being and mental health support in the workplace. Through community organizing and activism, they raise awareness about the negative impact of capitalist pressures on mental health and advocate for systemic change within the industry.

Cultivating a Culture of Collective Care

Building a culture of collective care and support within the tech community is crucial for fostering resilience and solidarity. By sharing experiences, offering mentorship, and advocating for inclusive and supportive workplaces, we can create environments where individuals feel valued, supported, and empowered to thrive.

Example:

Tech Allies, a network of tech professionals dedicated to promoting diversity, inclusion, and mental health awareness in the industry, hosts regular community events and workshops focused on self-care, stress management, and mental health support. By creating spaces for open dialogue and mutual support, they foster a culture of collective care and resilience within the tech community.

Conclusion: Towards a Future of Balance and Well-being

In conclusion, lifelong learning in the tech field has the power to both empower individuals and exacerbate mental health challenges within the constraints of capitalism. As we navigate this complex intersection, it's essential to prioritize well-being, advocate for systemic change, and cultivate cultures of care and support within our communities.

Let's envision a future where lifelong learning is celebrated as a tool for personal growth and societal advancement, where individuals are valued not solely for their productivity but for their humanity, and where well-being is prioritized over profit.🌱💻🧠

Creating Custom Exception Handlers in Each Package of a Spring Boot Project

Dina Essam — Sat, 06 Jan 2024 19:00:00 +0000

Greetings, developers! Today, we'll explore the process of creating custom exception handlers within each package of a Spring Boot project. Join us on this journey as we go through the steps and provide an illustrative example of setting up custom exception handling in different project packages. Let's dive into the world of handling exceptions! 🚀🔍

Understanding the Importance of Custom Exception Handling in Spring Boot

Custom exception handling is crucial in Spring Boot applications to manage and gracefully handle different types of exceptions that may occur across various layers or modules of the application.

Steps to Create Custom Exception Handlers in Each Package

Step 1: Define Custom Exceptions in Each Package

Create custom exception classes within each package to handle specific errors or exceptional scenarios.

// Custom exception class in package com.example.user
package com.example.user;

public class UserNotFoundException extends RuntimeException {
    public UserNotFoundException(String message) {
        super(message);
    }
}

// Custom exception class in package com.example.product
package com.example.product;

public class ProductNotFoundException extends RuntimeException {
    public ProductNotFoundException(String message) {
        super(message);
    }
}
// ... and so on for other packages as needed

Step 2: Implement Custom Exception Handlers

Develop custom exception handler classes in each package to handle corresponding exceptions, utilizing @ControllerAdvice with basePackages attribute.

// Exception handler class in package com.example.user
package com.example.user;

@ControllerAdvice(basePackages = "com.example.user")
public class UserExceptionHandler {

    @ExceptionHandler(UserNotFoundException.class)
    public ResponseEntity<String> handleUserNotFoundException(UserNotFoundException ex) {
        return ResponseEntity.status(HttpStatus.NOT_FOUND).body(ex.getMessage());
    }
}

// Exception handler class in package com.example.product
package com.example.product;

@ControllerAdvice(basePackages = "com.example.product")
public class ProductExceptionHandler {

    @ExceptionHandler(ProductNotFoundException.class)
    public ResponseEntity<String> handleProductNotFoundException(ProductNotFoundException ex) {
        return ResponseEntity.status(HttpStatus.NOT_FOUND).body(ex.getMessage());
    }
}
// ... and so on for other packages as needed

Step 3: Register Exception Handlers in Main Application

Ensure the registration of all exception handlers by specifying basePackages in the main application.

@SpringBootApplication
@ComponentScan(basePackages = {"com.example.user", "com.example.product", /*... other package names */})
public class YourSpringBootApplication {
    public static void main(String[] args) {
        SpringApplication.run(YourSpringBootApplication.class, args);
    }
}

Conclusion: Enhancing Exception Handling with Custom Handlers Across Packages in Spring Boot

Custom exception handling in each package of a Spring Boot project empowers developers to efficiently manage and handle exceptions specific to different modules or layers within the application. By creating custom exceptions and respective handlers in each package, the application gains better control over error handling and enhances its overall robustness.

Happy coding, and may your custom exception handling strategies streamline error management in your Spring Boot projects! 🛠️🌐👨‍💻

Mastering Advanced Spring Data Specifications within Spring Data Repositories for Complex Queries in Spring Boot

Dina Essam — Fri, 05 Jan 2024 19:00:00 +0000

Greetings, fellow developers! Today, we're delving into the intricate world of Spring Data Specifications within the Spring Boot framework. Join us on this exploration as we uncover the prowess of Specifications in crafting advanced and complex queries within Spring Data Repositories. Let's dive deeper into the realm of advanced querying! 🌟🔍

Understanding Advanced Spring Data Specifications in Spring Boot

Unveiling the Power of Specifications

Spring Data Specifications offer a robust toolset allowing developers to construct complex and parameterized query predicates, facilitating sophisticated data retrieval and manipulation.

Key Features of Advanced Spring Data Specifications Integration:

1. Complex Predicate Composition:

Specifications empower developers to compose intricate query predicates combining multiple criteria and logical operations.

2. Parameterized Specifications:

Parameterized Specifications provide flexibility by enabling the creation of reusable and adaptable query predicates for various scenarios.

3. Query Optimization:

Specifications facilitate optimized query execution, ensuring efficient data retrieval by utilizing database indexes and other optimization techniques.

Implementing Complex Queries using Advanced Spring Data Specifications in Spring Boot

Example: Crafting Specifications for Advanced Queries

Let's create advanced Specifications for a product-related query scenario:

public class ProductSpecifications {

    public static Specification<Product> hasPriceGreaterThan(double price) {
        return (root, query, criteriaBuilder) ->
            criteriaBuilder.greaterThan(root.get("price"), price);
    }

    public static Specification<Product> hasCategory(String category) {
        return (root, query, criteriaBuilder) ->
            criteriaBuilder.equal(root.get("category"), category);
    }

    public static Specification<Product> hasPriceGreaterThanAndCategory(double price, String category) {
        return Specification.where(hasPriceGreaterThan(price)).and(hasCategory(category));
    }
}

Integrating Advanced Specifications in Spring Data Repository

Integrate the complex Specifications into the Spring Data Repository for product data retrieval:

public interface ProductRepository extends JpaRepository<Product, Long>, JpaSpecificationExecutor<Product> {
    // Spring Data methods will be inherited along with custom specifications
}

Leveraging Advanced Specifications in a Service

Utilize the advanced Specifications within a Spring Boot service:

@Service
public class ProductService {

    private final ProductRepository productRepository;

    public ProductService(ProductRepository productRepository) {
        this.productRepository = productRepository;
    }

    public List<Product> getProductsByPriceAndCategory(double price, String category) {
        Specification<Product> spec = ProductSpecifications.hasPriceGreaterThanAndCategory(price, category);
        return productRepository.findAll(spec);
    }

    // Additional methods utilizing complex Specifications within the service
}

Conclusion: Harnessing Advanced Spring Data Specifications for Complex Queries in Spring Boot

Advanced Spring Data Specifications provide a powerful mechanism for constructing intricate and optimized query predicates within Spring Data Repositories. By leveraging these specifications, developers can effortlessly craft complex queries tailored to specific criteria, enhancing data retrieval and manipulation in Spring Boot applications.

Happy coding, and may your advanced Specifications simplify and optimize your complex querying endeavors! 🚀🌐💻

Exploring All Query Types in Spring Data Repositories

Dina Essam — Fri, 05 Jan 2024 07:00:00 +0000

Hello fellow developers! We're taking a deep dive into the diverse spectrum of query types supported by Spring Data Repositories. Join us as we explore each query type with examples, and then venture into crafting highly intricate queries using Spring Data Specifications in a Spring Boot environment. Let's dive into the world of querying! 🌟🔍

Understanding Different Query Types in Spring Data Repositories

1. Simple Queries:

Simple queries involve methods derived from Spring Data repository interfaces, enabling basic CRUD operations.

public interface ProductRepository extends JpaRepository<Product, Long> {
    // Simple query for finding products by category
    List<Product> findByCategory(String category);
}

2. Query Methods:

Spring Data enables the creation of custom query methods using method naming conventions, supporting parameterized queries.

public interface ProductRepository extends JpaRepository<Product, Long> {
    // Query method with parameters for finding products by name and price
    List<Product> findByNameAndPrice(String name, double price);
}

3. JPQL Queries:

Java Persistence Query Language allows developers to craft more complex queries using object-oriented concepts.

public interface OrderRepository extends JpaRepository<Order, Long> {
    // JPQL query for finding orders by status
    @Query("SELECT o FROM Order o WHERE o.status = :status")
    List<Order> findOrdersByStatus(@Param("status") String status);
}

4. Native Queries:

Native queries permit the execution of SQL queries directly, providing flexibility for intricate database-specific operations.

public interface OrderRepository extends JpaRepository<Order, Long> {
    // Native query for finding orders by customer ID
    @Query(value = "SELECT * FROM orders WHERE customer_id = :customerId", nativeQuery = true)
    List<Order> findOrdersByCustomerId(@Param("customerId") Long customerId);
}

5. Specifications:

Spring Data Specifications allow for the creation of complex and reusable query predicates.

public class OrderSpecifications {

    public static Specification<Order> hasComplexCriteria(/* Parameters as needed */) {
        return (root, query, criteriaBuilder) -> {
            // Define complex query logic using criteriaBuilder
            return criteriaBuilder.and(/* Complex criteria predicates */);
        };
    }
}

Conclusion: A Dive into the World of Querying in Spring Data Repositories

Spring Data Repositories offer a diverse range of query types, from simple CRUD operations to advanced JPQL, native queries, and Specifications. Each query type caters to different data retrieval needs, empowering developers to tailor their queries to specific scenarios in Spring Boot applications.

Happy coding, and may your understanding of query types enrich your data retrieval experiences! 🚀🌐💻

Exploring the Synergy of Multiple Spring Custom Repositories within Spring Data Repositories in Spring Boot

Dina Essam — Thu, 04 Jan 2024 19:00:00 +0000

Hello, dear developers! Today, we're embarking on an enlightening journey into the intricate world of Spring Data repositories within the Spring Boot ecosystem. Specifically, we'll uncover the seamless integration of multiple custom repositories within Spring Data repositories. Let's unravel the power of this fusion through multiple examples, unlocking the potential of custom repositories within Spring Data. Join us as we dive into this enriching experience! 🌟🛠️

Unveiling the Integration: Multiple Custom Repositories Inside Spring Data Repositories

Leveraging Multiple Custom Repositories in Spring Data

The fusion of multiple custom repositories within Spring Data repositories empowers developers to extend repository functionalities by integrating multiple specialized repositories alongside Spring Data’s default CRUD operations.

Key Features of Integrating Multiple Custom Repositories in Spring Data:

1. Enhanced Repository Functionality:

Integrating multiple custom repositories augments the capabilities of Spring Data repositories, allowing developers to incorporate various specialized repositories into a unified interface.

2. Versatile Data Access Solutions:

Multiple custom repositories offer a broader spectrum of data access solutions, encompassing diverse specialized methods tailored to specific business requirements.

3. Modular Repository Architecture:

The integration of multiple custom repositories promotes modularity, facilitating the division of complex business logic into separate repositories for improved organization and maintainability.

Implementing Multiple Custom Repositories Within Spring Data Repositories in Spring Boot

Example 1: Defining Multiple Custom Repositories

Let's start by creating multiple custom repository interfaces and integrating them within a Spring Data repository:

public interface CustomProductRepository {
    // Custom methods for product-related operations
    List<Product> findAllDiscountedProducts();
    List<Product> findAllNewlyAddedProducts();
}

public interface CustomOrderRepository {
    // Custom methods for order-related operations
    List<Order> findOrdersByStatus(String status);
    List<Order> findOrdersByCustomer(Customer customer);
}

public interface CombinedRepository extends JpaRepository<Product, Long>,
        CustomProductRepository, CustomOrderRepository {
    // Inherited Spring Data methods along with custom repository methods
}

Example 2: Implementing Custom Repository Logic

Implement the custom repository methods within respective repository implementation classes:

public class CustomProductRepositoryImpl implements CustomProductRepository {

    private final EntityManager entityManager;

    public CustomProductRepositoryImpl(EntityManager entityManager) {
        this.entityManager = entityManager;
    }

    @Override
    public List<Product> findAllDiscountedProducts() {
        // Custom logic to retrieve discounted products
        // Use entityManager or custom queries
        return entityManager.createQuery("SELECT p FROM Product p WHERE p.discount > 0", Product.class).getResultList();
    }

    @Override
    public List<Product> findAllNewlyAddedProducts() {
        // Custom logic to retrieve newly added products
        // Use entityManager or custom queries
        return entityManager.createQuery("SELECT p FROM Product p WHERE p.dateAdded > :lastWeek", Product.class)
                .setParameter("lastWeek", LocalDate.now().minusWeeks(1))
                .getResultList();
    }
}

public class CustomOrderRepositoryImpl implements CustomOrderRepository {

    private final EntityManager entityManager;

    public CustomOrderRepositoryImpl(EntityManager entityManager) {
        this.entityManager = entityManager;
    }

    @Override
    public List<Order> findOrdersByStatus(String status) {
        // Custom logic to retrieve orders by status
        // Use entityManager or custom queries
        return entityManager.createQuery("SELECT o FROM Order o WHERE o.status = :status", Order.class)
                .setParameter("status", status)
                .getResultList();
    }

    @Override
    public List<Order> findOrdersByCustomer(Customer customer) {
        // Custom logic to retrieve orders by customer
        // Use entityManager or custom queries
        return entityManager.createQuery("SELECT o FROM Order o WHERE o.customer = :customer", Order.class)
                .setParameter("customer", customer)
                .getResultList();
    }
}

Example 3: Utilizing Combined Repository in a Service

Leverage the combined repository within a Spring Boot service:

@Service
public class DataService {

    private final CombinedRepository combinedRepository;

    public DataService(CombinedRepository combinedRepository) {
        this.combinedRepository = combinedRepository;
    }

    public List<Product> fetchAllDiscountedProducts() {
        return combinedRepository.findAllDiscountedProducts();
    }

    public List<Order> fetchOrdersByStatus(String status) {
        return combinedRepository.findOrdersByStatus(status);
    }

    // Additional methods utilizing the combined repository
}

Conclusion: Harnessing the Synergy of Multiple Custom Repositories within Spring Data

The integration of multiple custom repositories within Spring Data repositories offers a robust and versatile solution for enhanced data access in Spring Boot applications. By combining multiple specialized repositories, developers can unify diverse functionalities, streamline data access, and craft modular repository architectures.

Happy coding, and may your combined repositories bring efficiency and adaptability to your applications! 🚀🌐💻

Aspect-Oriented Programming (AOP) in Spring Boot

Dina Essam — Thu, 04 Jan 2024 07:00:00 +0000

Hello developers! Welcome to an in-depth exploration of Aspect-Oriented Programming (AOP) in Spring Boot. In this guide, we'll dive deep into the concepts of AOP, its implementation in Spring Boot, and practical examples to demonstrate its effectiveness in managing cross-cutting concerns.

Understanding Aspect-Oriented Programming (AOP)

Aspect-Oriented Programming (AOP) is a powerful paradigm that allows modularizing cross-cutting concerns, enabling cleaner and more maintainable code. In Spring Boot, AOP provides a way to encapsulate common functionalities, such as logging, security, and transaction management, into reusable components called aspects.

Key Concepts in AOP

1. Aspect

An aspect is a module that encapsulates cross-cutting concerns. In Spring Boot, aspects can be implemented using annotations or XML configuration.

2. Join Point

A join point is a specific point in the application where an aspect can be applied, such as method execution, exception handling, etc.

3. Advice

Advice represents the action taken by an aspect at a particular join point. Spring Boot supports various advice types: @Before, @After, @Around, @AfterReturning, and @AfterThrowing.

4. Pointcut

A pointcut is a set of one or more join points where advice should be executed. It specifies when and where an aspect should be applied in the code.

Traditional Approach - Without AOP

Consider a Spring Boot application without utilizing AOP. In this scenario, let's focus on a common cross-cutting concern: logging method executions

@Service
public class UserService {

    private final Logger logger = LoggerFactory.getLogger(UserService.class);

    public void addUser(User user) {
        logger.info("Adding user: {}", user.getUsername());
        // Business logic to add user
    }

    public User getUserById(Long userId) {
        logger.info("Fetching user by ID: {}", userId);
        // Business logic to retrieve user
    }
}

Analysis

Code Duplication: Logging statements are scattered across multiple methods, leading to code redundancy.
Maintenance Challenges: Updating or modifying logging behavior requires changing each method individually, leading to maintenance challenges.

Implementing AOP in Spring Boot

Now, let's revisit the same application but leveraging Aspect-Oriented Programming in Spring Boot to handle logging.

@Aspect
@Component
public class LoggingAspect {

    private final Logger logger = LoggerFactory.getLogger(LoggingAspect.class);

    @Before("execution(* com.example.myapp.service.*.*(..))")
    public void beforeMethodExecution(JoinPoint joinPoint) {
        logger.info("Executing method: {}", joinPoint.getSignature().toShortString());
    }
}

Enable AOP in the Spring Boot application using @EnableAspectJAutoProxy annotation in the main application class.

@SpringBootApplication
@EnableAspectJAutoProxy
public class MyApplication {

    public static void main(String[] args) {
        SpringApplication.run(MyApplication.class, args);
    }
}

Analysis

Code Reusability: By applying the logging aspect, the logging behavior is reusable across multiple methods, reducing code duplication.
Modularity: AOP allows the separation of logging concerns into a distinct aspect, promoting modularity and cleaner code.

Practical Examples of AOP Usage in Spring Boot

Logging

Implement logging using AOP to log method executions before and after service or controller methods.

Transaction Management

Utilize AOP for managing transactions by applying transactional aspects to methods requiring transactional behavior.

Security

Apply security aspects using AOP to enforce authorization or authentication rules across the application.

Conclusion:

Aspect-Oriented Programming in Spring Boot allows for the modularization of cross-cutting concerns, leading to cleaner and more maintainable code. By encapsulating common functionalities into aspects, developers can focus on the core business logic while ensuring consistency and scalability across the application.

Happy coding, and may Aspect-Oriented Programming streamline your Spring Boot applications! 🚀👨‍💻

Mastering Multiple Data Sources with Transaction Management in Spring Boot

Dina Essam — Wed, 03 Jan 2024 19:00:00 +0000

Greetings, fellow developers! Today, let's embark on a captivating journey into the world of Spring Boot and its remarkable capability to manage two data sources within a single application, all while gracefully handling transactions. 🚀

Necessity of Handling Multiple Data Sources and Transactions

In enterprise-grade applications, the need often arises to interact with multiple databases concurrently. This could involve managing critical data across distinct databases while ensuring the integrity and consistency of transactions across these sources.

Configuring Multiple Data Sources and Transaction Management in Spring Boot

Step 1: Defining Data Source Properties

In your application.properties or application.yml, specify the configurations for both data sources:

# Primary Database Configuration
spring.datasource.primary.url=jdbc:mysql://localhost:3306/primarydb
spring.datasource.primary.username=dbuser1
spring.datasource.primary.password=dbpassword1
spring.datasource.primary.driver-class-name=com.mysql.cj.jdbc.Driver

# Secondary Database Configuration
spring.datasource.secondary.url=jdbc:mysql://localhost:3306/secondarydb
spring.datasource.secondary.username=dbuser2
spring.datasource.secondary.password=dbpassword2
spring.datasource.secondary.driver-class-name=com.mysql.cj.jdbc.Driver

Step 2: Configuring DataSource Beans

Let’s configure these data sources as beans and enable transaction management:

@Configuration
@EnableTransactionManagement
public class DataSourceConfig {

    @Primary
    @Bean(name = "primaryDataSource")
    @ConfigurationProperties(prefix = "spring.datasource.primary")
    public DataSource primaryDataSource() {
        return DataSourceBuilder.create().build();
    }

    @Bean(name = "secondaryDataSource")
    @ConfigurationProperties(prefix = "spring.datasource.secondary")
    public DataSource secondaryDataSource() {
        return DataSourceBuilder.create().build();
    }

    @Primary
    @Bean(name = "transactionManager")
    public PlatformTransactionManager primaryTransactionManager(@Qualifier("primaryDataSource") DataSource primaryDataSource) {
        return new DataSourceTransactionManager(primaryDataSource);
    }

    @Bean(name = "secondaryTransactionManager")
    public PlatformTransactionManager secondaryTransactionManager(@Qualifier("secondaryDataSource") DataSource secondaryDataSource) {
        return new DataSourceTransactionManager(secondaryDataSource);
    }
}

Utilizing Transactional Operations in Your Spring Boot Application

Now, let’s employ transactional capabilities while interacting with these data sources:

@Service
public class DataService {

    private final JdbcTemplate primaryJdbcTemplate;
    private final JdbcTemplate secondaryJdbcTemplate;

    public DataService(@Qualifier("primaryJdbcTemplate") JdbcTemplate primaryJdbcTemplate,
                       @Qualifier("secondaryJdbcTemplate") JdbcTemplate secondaryJdbcTemplate) {
        this.primaryJdbcTemplate = primaryJdbcTemplate;
        this.secondaryJdbcTemplate = secondaryJdbcTemplate;
    }

    @Transactional("transactionManager")
    public void performTransactionOnPrimaryDatabase() {
        // Perform transactional operations using primaryJdbcTemplate
        primaryJdbcTemplate.update("INSERT INTO table_in_primary VALUES (?, ?)", 1, "Data");
    }

    @Transactional("secondaryTransactionManager")
    public void performTransactionOnSecondaryDatabase() {
        // Perform transactional operations using secondaryJdbcTemplate
        secondaryJdbcTemplate.update("INSERT INTO table_in_secondary VALUES (?, ?)", 2, "More Data");
    }
}

Conclusion:

With Spring Boot's impeccable handling of multiple data sources and its robust transaction management capabilities, you've unlocked the ability to execute transactions across different databases seamlessly. This empowers developers to build resilient and scalable applications, ensuring data integrity while operating across diverse data sources.

Happy coding, and may your Spring Boot applications thrive with flawless data management! 🌐💾🛠️

Demystifying Java Spring Framework: A Comprehensive Overview

Dina Essam — Wed, 03 Jan 2024 02:23:58 +0000

Welcome, fellow enthusiasts of software development! Today, we embark on an illuminating journey through the fundamental concepts of Java Spring, a robust framework that empowers developers to craft scalable, efficient, and maintainable applications.

Understanding Java Spring: A Framework Overview

Java Spring isn't just any framework; it's a powerhouse of tools and conventions that simplifies the intricacies of Java-based application development. At its core, Spring promotes a modular and cohesive approach, enabling developers to create applications with ease.

Core Concepts Unveiled:

1. Inversion of Control (IoC) Container:

The IoC container in Spring is akin to the conductor of an orchestra, orchestrating the creation and management of objects. It flips the traditional programming model, allowing the container to take charge of object instantiation and their interdependencies.

// Your code can focus on what to do, rather than how to do it!
public class MagicalApp {
    private MagicalService magicalService;

    public MagicalApp(MagicalService magicalService) {
        this.magicalService = magicalService;
    }

    public String castSpell(int wandId) {
        return magicalService.castSpell(wandId);
    }
}

2. Dependency Injection (DI):

DI in Spring revolves around the principle of "Don't call us; we'll call you." It involves injecting dependencies into objects, reducing tight coupling and making components easily replaceable or testable.

// DI brings everything together like a magical spellbook!
@Service
public class MagicalService {
    private WandRepository wandRepository;

    @Autowired
    public MagicalService(WandRepository wandRepository) {
        this.wandRepository = wandRepository;
    }

    public String castSpell(int wandId) {
        // Do something magical with the wand!
        return "Expecto Patronum!";
    }
}

3. Aspect-Oriented Programming (AOP):

AOP complements Spring by modularizing concerns that span across application components, such as logging, security, and transaction management. It enables developers to encapsulate these cross-cutting concerns, promoting cleaner code organization.

// AOP helps sprinkle magic all around without being seen!
@Aspect
@Component
public class MagicLogger {
    @Before("execution(* com.example.*.*(..))")
    public void beforeCastingSpell(JoinPoint joinPoint) {
        System.out.println("Preparing to cast a spell...");
    }
}

4. Spring MVC (Model-View-Controller):

Spring MVC, following the famous MVC architectural pattern, separates an application into three interconnected components: Models (business logic), Views (presentation layer), and Controllers (handling user requests). This segregation facilitates a clear and structured development process.

// Spring MVC makes playing with your app more fun!
@Controller
@RequestMapping("/magic")
public class MagicController {

    @Autowired
    private MagicalService magicalService;

    @GetMapping("/spell/{wandId}")
    public String castSpell(@PathVariable("wandId") int wandId, Model model) {
        String spellResult = magicalService.castSpell(wandId);
        model.addAttribute("spellResult", spellResult);
        return "spellResultPage"; // It's like showing off your magic!
    }
}

5. Spring Boot:

Spring Boot emerges as a game-changer, providing an out-of-the-box solution for setting up Spring-based applications. It streamlines configuration, reduces boilerplate code, and offers powerful features for rapid development.

// Spring Boot - Your instant magic wand for starting apps!
@SpringBootApplication
public class MagicApplication {

    public static void main(String[] args) {
        SpringApplication.run(MagicApplication.class, args);
    }
}

6. Spring Data:

Spring Data simplifies data access by offering a consistent and intuitive approach to interact with various data stores, abstracting away complexities and promoting ease of use.

// Spring Data helps your app interact with the magical database!
@Repository
public interface WandRepository extends JpaRepository<Wand, Long> {
    List<Wand> findByMagicType(String magicType);
}

Embracing Spring's Power in Real-world Scenarios:

A Sample Use Case:

Consider an e-commerce platform leveraging Spring. The IoC container would manage objects like User, Product, and Order, ensuring seamless interactions among them. DI would inject necessary services, such as Payment and Shipping, into these objects. AOP could handle security aspects like authentication and authorization. Spring MVC would organize the web interface, and Spring Boot would swiftly kickstart the application.

Conclusion:

Java Spring Framework, with its IoC, DI, AOP, Spring MVC, Spring Boot, and Spring Data components, acts as a guiding beacon for developers. By embracing these concepts, developers can architect applications that are not only powerful but also maintainable and scalable.

So, as you journey deeper into the realm of Java Spring, may these foundational concepts empower you to craft applications that stand the test of time.

Happy coding, and may your Spring be evergreen! 🌱✨

DEV Community: Dina Essam

Java Multi-threading Gone Wrong: A Real-World Backend Nightmare

How It All Went Wrong

The Problematic Code:

Why Your Backend Froze

The Fix: Smarter Locking

Option 1: Consistent Locking Order

Option 2: Use tryLock() to Avoid Deadlocks

Final Thoughts: Taming Multi-threading

The Impact of Capitalism on Human Mental Health: Unveiling the Toll on Well-being

Understanding Capitalism's Influence

Commodification of Human Experience

Exploitative Labor Practices

Growing Economic Inequality

The Toll on Mental Health

Stress and Anxiety

Depression and Burnout

Alienation and Isolation

Navigating Towards Well-being

Building Supportive Communities

Advocating for Systemic Change

Prioritizing Self-care

Conclusion: Towards a More Compassionate Future

Bridging the Gap: Aligning University Education with the Tech Job Market

Understanding the Discrepancy

Theoretical vs. Practical Learning

Evolving Industry Demands

Bridging the Divide

Industry-Academia Collaboration

Practical Skill Development

Lifelong Learning Mindset

Conclusion: Navigating the Path Forward

The Impact of Lifelong Learning in the Tech Field on Human Mental Health: Balancing Progress with Well-being

Lifelong Learning in the Tech Field: A Double-Edged Sword

Empowering Innovation and Growth

The Pressure to Perform

The Toll on Mental Health: Capitalism's Influence

Commodification of Knowledge

Precarity and Insecurity

Hyper-Competitive Culture

Navigating the Intersection: Striving for Balance and Well-being

Prioritizing Self-care and Boundaries

Advocating for Systemic Change

Cultivating a Culture of Collective Care

Conclusion: Towards a Future of Balance and Well-being

Creating Custom Exception Handlers in Each Package of a Spring Boot Project

Understanding the Importance of Custom Exception Handling in Spring Boot

Steps to Create Custom Exception Handlers in Each Package

Step 1: Define Custom Exceptions in Each Package

Step 2: Implement Custom Exception Handlers

Step 3: Register Exception Handlers in Main Application

Conclusion: Enhancing Exception Handling with Custom Handlers Across Packages in Spring Boot

Mastering Advanced Spring Data Specifications within Spring Data Repositories for Complex Queries in Spring Boot

Understanding Advanced Spring Data Specifications in Spring Boot

Unveiling the Power of Specifications

Key Features of Advanced Spring Data Specifications Integration:

1. Complex Predicate Composition:

2. Parameterized Specifications:

3. Query Optimization:

Implementing Complex Queries using Advanced Spring Data Specifications in Spring Boot

Example: Crafting Specifications for Advanced Queries

Integrating Advanced Specifications in Spring Data Repository

Leveraging Advanced Specifications in a Service

Conclusion: Harnessing Advanced Spring Data Specifications for Complex Queries in Spring Boot

Exploring All Query Types in Spring Data Repositories

Understanding Different Query Types in Spring Data Repositories

1. Simple Queries:

2. Query Methods:

3. JPQL Queries:

4. Native Queries:

5. Specifications:

Conclusion: A Dive into the World of Querying in Spring Data Repositories

Exploring the Synergy of Multiple Spring Custom Repositories within Spring Data Repositories in Spring Boot

Unveiling the Integration: Multiple Custom Repositories Inside Spring Data Repositories

Leveraging Multiple Custom Repositories in Spring Data

Key Features of Integrating Multiple Custom Repositories in Spring Data:

1. Enhanced Repository Functionality:

2. Versatile Data Access Solutions:

3. Modular Repository Architecture:

Implementing Multiple Custom Repositories Within Spring Data Repositories in Spring Boot

Option 2: Use `tryLock()` to Avoid Deadlocks