The difference between design patterns and architectural patterns in Java framework

In the Java framework, the difference between design patterns and architectural patterns is that design patterns define abstract solutions to common problems in software design, focusing on the interaction between classes and objects, such as factory patterns. Architectural patterns define the relationship between system structures and modules, focusing on the organization and interaction of system components, such as layered architecture.

The difference between design patterns and architectural patterns in the Java framework

In the Java framework, design patterns and architectural patterns are closely related Related concepts, but there are differences.

Design Patterns

• Definition: Abstract-level solutions to common problems in software design.
• Focus on: the interaction between classes and objects.
• For example: factory pattern, singleton pattern, observer pattern.

Architectural Pattern

• Definition: Define the structure of the system and clarify the relationship between modules.
• Focus on: Organization and interaction of system components.
• For example: layered architecture, microservice architecture, event-driven architecture.

Practical case

Design pattern

Use the factory pattern to create an object factory that handles tasks:

public class TaskFactory {
    public Task createTask(String taskType) {
        Task task;
        switch (taskType) {
            case "email":
                task = new EmailTask();
                break;
            case "sms":
                task = new SmsTask();
                break;
            default:
                throw new InvalidTaskTypeException();
        }
        return task;
    }
}

Architectural Patterns

Use a layered architecture to organize Java web applications:

// Controller层
@Controller
public class TaskController {
    private TaskService taskService;

    @PostMapping("/tasks")
    public ResponseEntity<Task> createTask(@RequestBody TaskDto taskDto) {
        Task task = taskService.createTask(taskDto);
        return ResponseEntity.ok(task);
    }
}

// Service层
public class TaskService {
    public Task createTask(TaskDto taskDto) {
        Task task = TaskFactory.createTask(taskDto.getType());
        task.setName(taskDto.getName());
        return task;
    }
}

// Repository层
public interface TaskRepository {
    Task save(Task task);

    List<Task> findAll();
}

The above is the detailed content of The difference between design patterns and architectural patterns in Java framework. For more information, please follow other related articles on the PHP Chinese website!