What Is Software Architecture? Core Concepts, Common Technologies, and Common Pitfalls

Introduction

In an era of abundant knowledge sharing, the Java ecosystem offers a wealth of frameworks, middleware, and toolkits. While many developers can name SSM, micro‑services, clustering, multithreading, and high‑concurrency techniques, it is worth pausing to ask what software architecture truly means and what role these components play.

Background

The author, with nearly four years of experience, started on monolithic Java projects (Spring, Struts2, Hibernate) deployed as a single WAR on Tomcat, handling a modest QPS of less than five. After moving to a company that adopted Dubbo‑based micro‑services, the system grew to millions of requests across 23 servers. Later, services were containerized as Docker images, and Git‑based CI/CD dramatically improved development, deployment, and operations efficiency.

What Is Software Architecture?

According to Wikipedia, software architecture is a high‑level sketch of a system, describing abstract components and their interactions. A software architect designs module boundaries, communication protocols, UI style, external APIs, and high‑level workflows. An analogy to the human body helps: organs (components) perform specific functions, blood (data) flows through vessels (communication channels), and the skin (UI) presents the system to users. Technologies such as Kafka, Redis, SSM, RabbitMQ, and XXL‑Job are individual components that together form the overall architecture.

Common Architecture Technologies

Distributed Systems

Splitting a codebase into independent services that communicate via RPC or WebService improves decoupling, deployment flexibility, and horizontal scalability. Advantages include easier maintenance, independent scaling, and language‑agnostic services. Drawbacks are network latency, increased complexity, higher operational costs for small workloads, challenges with distributed transactions (often requiring 2‑phase commit), session consistency, and the need for robust fault tolerance.

Clustering

Deploying the same application on multiple servers (nodes) increases CPU, memory, and I/O capacity. Load balancers distribute requests among nodes, allowing simple horizontal scaling until hardware or architectural limits are reached.

Caching

Caching accelerates data access and offloads backend databases. Single‑node caches (e.g., HashMap, ConcurrentHashMap, Guava) have limited capacity, while distributed caches (e.g., Redis, Memcached) provide scalability. Two primary benefits are faster reads and reduced database load. Common pitfalls include cache avalanche, cache breakdown, and cache penetration, mitigated respectively by randomizing expiration times, keeping hot keys permanently cached, and using Bloom filters.

Message Queues

Queues decouple request spikes (e.g., Double‑11 order bursts) from backend processing. Producers push orders to a queue and return immediately; consumers process orders at a controlled rate, smoothing traffic and preventing database overload. A diagram illustrates the flow.

Multithreading

Multithreading improves CPU utilization and overall throughput on multi‑core servers. By parallelizing independent tasks, programs can handle compute‑intensive workloads more efficiently than single‑threaded execution.

Rate Limiting

To protect databases from high‑traffic attacks, rate limiting filters excessive requests. Common algorithms include Redis‑based token expiration, token‑bucket (e.g., Guava RateLimiter), leaky‑bucket, and sliding‑window (e.g., Alibaba Sentinel). Each balances fairness, burst handling, and implementation complexity.

Service Degradation and Circuit Breaking

As services proliferate, failures become more likely. Implementing degradation strategies and circuit breakers (e.g., Hystrix) prevents cascading failures and maintains partial availability when a small subset of instances crashes.

Security Issues

SQL Injection

Use prepared statements (e.g., JDBC PreparedStatement) to separate SQL logic from user input, preventing malicious code execution.

Cross‑Site Request Forgery (CSRF)

Mitigate by adding random tokens to requests, validating them server‑side, and optionally placing the token in HTTP headers.

Cross‑Site Scripting (XSS)

Filter or escape any user‑supplied scripts or dangerous CSS before rendering. Example code snippet:

filter any executable script or harmful CSS

Design Pitfalls

Over‑Engineering for Appearances

Adopting complex micro‑service architectures for small workloads adds unnecessary development and maintenance overhead. Architecture should fit business scale and evolve with growth.

Believing Technology Solves All Problems

Not every issue can be addressed by technical means; some require business‑level decisions, such as handling promotional ticket abuse that cannot be fully prevented by code alone.

Conclusion

The article provides a high‑level overview of software architecture, covering distributed systems, clustering, caching, micro‑services, queues, multithreading, rate limiting, security concerns, and common design mistakes. While the discussion is introductory, it aims to spark deeper exploration and practical learning.