The most commonly used design patterns in enterprise-level Java applications include: 1. Creation mode: Singleton mode is used to ensure globally unique instances, such as log manager; factory method mode is used to decouple object creation, such as database connection creation; abstract factory mode is used to create object families, such as cross-platform UI components. 2. Structural mode: Agent mode is used to control object access, such as remote calls and delayed loading; Adapter mode is used for interface conversion, such as integrated WeChat payment; Decorator mode is used for dynamic expansion functions, such as packaging of Java I/O streams. 3. Behavioral mode: Observer mode is used for status notification, such as event monitoring system; policy mode is used to encapsulate variable algorithms, such as different discount policies; template method mode is used to define algorithm skeletons, such as order processing flow. 4. Compound mode and framework integration: DAO mode separates data access logic; Spring framework integrates factory mode (BeanFactory), proxy mode (AOP), template method (JdbcTemplate) and observer mode (event driven). The rational use of these patterns can improve the maintainability, scalability and reusability of the code, but over-design should be avoided, simplicity should be given priority, and framework capabilities should be combined with decoupling and testability to ultimately achieve high-quality enterprise-level systems.

In enterprise-level Java application development, Design Patterns are a mature solution to common architecture and code organization problems. They help developers build maintainable, scalable, and reusable systems. The following are the most commonly used design patterns in enterprise-level Java applications, which are classified by category and explained in combination with actual scenarios.

1. Creational Patterns

This type of pattern focuses on the object creation mechanism and helps the system create, combine and represent objects independently.

Singleton

Make sure that a class has only one instance and provides a global access point.

Applicable scenarios : database connection pool, log manager, configuration manager.

 public class Logger {
    private static Logger instance;

    private Logger() {}

    public static synchronized Logger getInstance() {
        if (instance == null) {
            instance = new Logger();
        }
        return instance;
    }
}

Note: In a multi-threaded environment, double check locking or static internal class method is required to ensure thread safety.

Factory Method

Define an interface to create an object, but the subclass determines which class to instantiate.

Applicable scenarios : Connection creation of different database vendors (MySQLConnectionFactory vs OracleConnectionFactory).

 interface DatabaseConnection {
    void connect();
}

class MySQLConnection implements DatabaseConnection {
    public void connect() { System.out.println("MySQL connected"); }
}

class ConnectionFactory {
    public DatabaseConnection getConnection(String type) {
        if ("mysql".equals(type)) return new MySQLConnection();
        // Other types...
        return null;
    }
}

Abstract Factory

Create a family of related or dependent objects without specifying concrete classes.

Applicable scenarios : UI component library (WindowsFactory vs MacFactory create buttons, text boxes, etc.).

2. Structural Patterns

This type of pattern processes the combination of classes or objects to form a larger structure.

Proxy mode (Proxy)

Provides a proxy for other objects to control access to this object.

Applicable scenarios : Remote service call (RMI), Lazy loading, and permission control.

 public interface Image {
    void display();
}

public class RealImage implements Image {
    private String filename;
    public RealImage(String filename) {
        this.filename = filename;
        loadFromDisk();
    }
    private void loadFromDisk() { System.out.println("Loading " filename); }
    public void display() { System.out.println("Displaying " filename); }
}

public class ProxyImage implements Image {
    private RealImage realImage;
    private String filename;

    public ProxyImage(String filename) {
        this.filename = filename;
    }

    public void display() {
        if (realImage == null) {
            realImage = new RealImage(filename);
        }
        realImage.display();
    }
}

Adapter mode (Adapter)

Convert an interface of one class to another interface the client wants.

Applicable scenarios : Integrate third-party payment gateways (such as WeChat payment interface adapted to a unified Payment interface).

 interface Payment {
    void pay(double amount);
}

class WeChatPay {
    public void wxPay(String account, double amount) {
        System.out.println("WeChat paid: " amount);
    }
}

class WeChatAdapter implements Payment {
    private WeChatPay weChatPay = new WeChatPay();

    public void pay(double amount) {
        weChatPay.wxPay("default", amount);
    }
}

Decorator mode

Dynamically add some extra responsibilities to an object, which is more flexible than inheritance.

Applicable scenario : Java I/O stream (BufferedInputStream Decorate FileInputStream).

 InputStream input = new BufferedInputStream(new FileInputStream("data.txt"));

3. Behavioral Patterns

This type of pattern focuses on communication and assignment of responsibilities between objects.

Observer mode (Observer)

Defines a one-to-many dependency between objects. When an object's state changes, all dependants will be notified.

Applicable scenarios : event monitoring mechanism, message subscription system.

 import java.util.*;

interface Observer {
    void update(String message);
}

class EmailService implements Observer {
    public void update(String message) {
        System.out.println("Email sent: " message);
    }
}

class EventManager {
    private List<Observer> observers = new ArrayList<>();

    public void addObserver(Observer o) {
        observers.add(o);
    }

    public void notifyObservers(String msg) {
        for (Observer o : observers) {
            o.update(msg);
        }
    }
}

ApplicationEvent and @EventListener in Spring are typical applications of this pattern.

Strategy

Define a series of algorithms, encapsulate them one by one, and make them replace each other.

Applicable scenarios : different discount strategies (full discount, percentage, buy one get one free).

 interface DiscountStrategy {
    double applyDiscount(double amount);
}

class PercentageDiscount implements DiscountStrategy {
    public double applyDiscount(double amount) {
        return amount * 0.9; // 10% off
    }
}

class Checkout {
    private DiscountStrategy strategy;

    public void setStrategy(DiscountStrategy strategy) {
        this.strategy = strategy;
    }

    public double checkout(double amount) {
        return strategy.applyDiscount(amount);
    }
}

Template Method

Define an algorithm skeleton in an operation and delay some steps to a subclass.

Applicable scenarios : Order processing process (verification → deduction of inventory → payment → delivery), some steps can be customized.

 abstract class OrderProcessTemplate {
    public final void processOrder() {
        validateOrder();
        deductInventory();
        payment();
        shipOrder();
    }

    abstract void payment();

    void validateOrder() { System.out.println("Validating order"); }
    void deductInventory() { System.out.println("Deducting inventory"); }
    void shipOrder() { System.out.println("Shipping order"); }
}

class OnlineOrder extends OrderProcessTemplate {
    void payment() { System.out.println("Processing online payment"); }
}

4. Integration of commonly used composite models and frameworks at the enterprise level

DAO mode (Data Access Object)

Separate business logic and data access logic, and are often used in accordance with the factory model.

 interface UserDao {
    User findById(Long id);
    void save(User user);
}

class UserDaoImpl implements UserDao {
    public User findById(Long id) {
        // JDBC / JPA query}
    // ...
}

Dependency Injection (DI) and Design Patterns in Spring

Spring frameworks use the above modes extensively:

• Factory model : BeanFactory
• Agent Mode : AOP Implementation (JDK Dynamic Proxy/CGLIB)
• Template method : JdbcTemplate , RestTemplate
• Observer Pattern : Event-driven Model

Summarize

In enterprise Java development, the rational use of design patterns can significantly improve code quality. But also avoid "over-design". Here are a few suggestions:

• Prioritize simplicity : Not every place requires patterns.
• Combined with framework capabilities : Spring, Hibernate and other models have been built in, so there is no need to re-create the wheel.
• Focus on testability and decoupling : The core goal of the mode is to reduce coupling and improve maintainability.

Basically that's it. Once you master these patterns, you will find that many of the enterprise code structures become "daily" - because they are all solving similar problems.

The above is the detailed content of Design Patterns in Java for Enterprise Applications. For more information, please follow other related articles on the PHP Chinese website!