Project Architecture Design
SPA vs. MPA Architecture Design
SPA Core Architecture:
src/
├── assets/ # Static assets
├── components/ # Common components
├── pages/ # Page components
├── routes/ # Route configurations
├── store/ # State management
├── services/ # API services
├── utils/ # Utility functions
└── App.js # Root componentMPA Architecture Features:
- Multiple independent HTML entry files.
- Each page is built and bundled separately.
- Suitable for SEO-heavy scenarios.
- Isolated state between pages.
SPA Advantages Comparison:
| Feature | SPA | MPA |
|---|---|---|
| User Experience | Seamless page transitions | Page reloads with white screen |
| Build Complexity | Single entry point | Multiple entry configurations |
| SEO Friendliness | Requires SSR support | Naturally SEO-friendly |
| Server Load | Lower after initial load | Full page requests each time |
Modular and Component-Based Design
Modular Design Principles:
- Functional Isolation: Each module has distinct responsibilities.
- Clear Interfaces: Well-defined module boundaries.
- Controlled Dependencies: Avoid circular dependencies.
Component Classification System:
components/
├── common/ # General-purpose components (Button, Input)
├── layout/ # Layout components (Header, Footer)
├── business/ # Business-specific components (ProductCard, OrderList)
└── hooks/ # Custom Hooks (useFetch, useAuth)Component Design Guidelines:
- Single Responsibility: One component, one purpose.
- Controlled Preference: Prioritize controlled component patterns.
- Props Design:
- Clearly mark required props.
- Set sensible default values.
- Define complex props with TypeScript interfaces.
State Management Architecture
Redux Architecture Design:
store/
├── index.js # Store configuration
├── features/ # Feature-based organization
│ ├── user/ # User module
│ │ ├── userSlice.js
│ │ └── userAPI.js
│ └── product/ # Product module
└── middleware/ # Custom middlewareMobX Architecture Features:
- Reactive Data: Automatically tracks dependencies.
- Less Boilerplate: Simpler than Redux.
- Object-Oriented: Ideal for domain model design.
State Management Selection Guidelines:
- Complex application state: Redux Toolkit.
- Simple state sharing: Context + useReducer.
- Domain-driven models: MobX.
- Server-side state: React Query/SWR.
Routing Architecture Design
Nested Routing Implementation:
<Routes>
<Route path="/" element={<Layout />}>
<Route index element={<Home />} />
<Route path="products" element={<Products />}>
<Route path=":id" element={<ProductDetail />} />
</Route>
<Route path="about" element={<About />} />
</Route>
</Routes>Dynamic Routing Configuration:
// Dynamic component import
const ProductPage = React.lazy(() => import('./pages/Product'));
// Permission-based routing
const ProtectedRoute = ({ children }) => {
const { isAuthenticated } = useAuth();
return isAuthenticated ? children : <Navigate to="/login" />;
};
<Routes>
<Route path="/admin" element={<ProtectedRoute />}>
<Route path="dashboard" element={<AdminDashboard />} />
</Route>
</Routes>Project Directory Standards
Recommended Directory Structure:
my-react-app/
├── .github/ # GitHub configurations
│ └── workflows/ # CI/CD workflows
├── public/ # Static assets (not bundled)
├── src/
│ ├── api/ # API request encapsulation
│ ├── assets/ # Images, fonts, etc.
│ ├── components/ # Reusable components
│ ├── config/ # Application configurations
│ ├── hooks/ # Custom Hooks
│ ├── layouts/ # Layout components
│ ├── pages/ # Page components
│ ├── routes/ # Route configurations
│ ├── store/ # State management
│ ├── styles/ # Global styles
│ ├── types/ # TypeScript types
│ ├── utils/ # Utility functions
│ ├── App.tsx # Root component
│ └── main.tsx # Entry file
├── .eslintrc.js # ESLint configuration
├── .prettierrc # Prettier configuration
├── tsconfig.json # TypeScript configuration
└── vite.config.ts # Vite configurationNaming Convention Recommendations:
- Component files:
PascalCase(e.g.,UserProfile.tsx). - Utility functions:
camelCase(e.g.,formatDate.ts). - Style files: Match component name (e.g.,
UserProfile.module.css). - Test files:
ComponentName.test.tsx.
Engineering Toolchain
Advanced CRA Configuration
Environment Variables Configuration:
# .env.development
REACT_APP_API_URL=http://localhost:3001
# .env.production
REACT_APP_API_URL=https://api.example.comProxy Configuration:
// craco.config.js (using craco to override CRA config)
module.exports = {
devServer: {
proxy: {
'/api': {
target: 'http://localhost:3001',
changeOrigin: true,
pathRewrite: { '^/api': '' }
}
}
}
}Deep Webpack Configuration
Custom Loader Example:
// webpack.config.js
module.exports = {
module: {
rules: [
{
test: /\.md$/,
use: [
'html-loader',
{
loader: path.resolve(__dirname, 'loaders/markdown-loader.js'),
options: { highlight: true }
}
]
}
]
}
}Performance Optimization Strategies:
- Code Splitting:
// Dynamic import
const LazyComponent = React.lazy(() => import('./LazyComponent'));
// Webpack magic comment
const HeavyComponent = React.lazy(() => import(
/* webpackChunkName: "heavy-component" */
'./HeavyComponent'
));- Caching Strategy:
output: {
filename: '[name].[contenthash].js',
chunkFilename: '[name].[contenthash].chunk.js'
}Vite Application Practices
Vite Configuration Example:
// vite.config.ts
import { defineConfig } from 'vite'
import react from '@vitejs/plugin-react'
export default defineConfig({
plugins: [react()],
server: {
port: 3000,
proxy: {
'/api': {
target: 'http://localhost:3001',
changeOrigin: true
}
}
},
build: {
rollupOptions: {
output: {
manualChunks: {
vendor: ['react', 'react-dom']
}
}
}
}
})Vite Advantages:
- Lightning-Fast Cold Start: ESM-based instant compilation.
- On-Demand Compilation: Compiles only the code needed for the current page.
- Native ESM: Development server without bundling.
Code Linting Tools
ESLint Configuration:
// .eslintrc.js
module.exports = {
extends: [
'eslint:recommended',
'plugin:react/recommended',
'plugin:@typescript-eslint/recommended'
],
rules: {
'react-hooks/rules-of-hooks': 'error',
'react-hooks/exhaustive-deps': 'warn'
},
settings: {
react: {
version: 'detect'
}
}
}Prettier Integration:
// .prettierrc
{
"semi": true,
"singleQuote": true,
"tabWidth": 2,
"trailingComma": "es5"
}Husky + lint-staged:
// package.json
{
"husky": {
"hooks": {
"pre-commit": "lint-staged"
}
},
"lint-staged": {
"*.{js,jsx,ts,tsx}": ["eslint --fix", "prettier --write"],
"*.{css,scss}": ["prettier --write"]
}
}Testing Framework Configuration
Jest Configuration:
// jest.config.js
module.exports = {
preset: 'ts-jest',
testEnvironment: 'jsdom',
setupFilesAfterEnv: ['<rootDir>/jest.setup.ts'],
moduleNameMapper: {
'\\.(css|less|scss|sass)$': 'identity-obj-proxy'
}
}React Testing Library Example:
// Button.test.tsx
import { render, screen, fireEvent } from '@testing-library/react'
import Button from './Button'
test('renders button with text', () => {
render(<Button>Click me</Button>)
const buttonElement = screen.getByText(/click me/i)
expect(buttonElement).toBeInTheDocument()
})
test('calls onClick when clicked', () => {
const handleClick = jest.fn()
render(<Button onClick={handleClick}>Click me</Button>)
fireEvent.click(screen.getByText(/click me/i))
expect(handleClick).toHaveBeenCalledTimes(1)
})Performance Optimization and Deployment
Code Splitting Strategies
Route-Level Splitting:
const Home = React.lazy(() => import('./pages/Home'))
const About = React.lazy(() => import('./pages/About'))
<Suspense fallback={<Spinner />}>
<Routes>
<Route path="/" element={<Home />} />
<Route path="/about" element={<About />} />
</Routes>
</Suspense>Component-Level Splitting:
const HeavyChart = React.lazy(() => import('./HeavyChart'))
function Dashboard() {
return (
<div>
<h1>Dashboard</h1>
<Suspense fallback={<ChartPlaceholder />}>
<HeavyChart />
</Suspense>
</div>
)
}Resource Optimization Strategies
Gzip Compression Configuration:
# Nginx configuration example
gzip on;
gzip_types text/plain text/css application/json application/javascript text/xml application/xml application/xml+rss text/javascript;
gzip_comp_level 6;
gzip_min_length 1024;CDN Configuration Best Practices:
- Static asset versioning:
main.[contenthash].js. - Cache strategies:
- HTML:
no-cache. - JS/CSS:
max-age=31536000. - Images:
max-age=604800.
- HTML:
SSR and SSG Solutions
Next.js SSR Configuration:
// pages/_app.tsx
import type { AppProps } from 'next/app'
import { Provider } from 'react-redux'
import store from '../store'
function MyApp({ Component, pageProps }: AppProps) {
return (
<Provider store={store}>
<Component {...pageProps} />
</Provider>
)
}
export default MyAppStatic Generation Optimization:
// pages/products/[id].tsx
export async function getStaticProps({ params }) {
const product = await fetchProduct(params.id)
return {
props: { product },
revalidate: 60 // ISR: Revalidate every 60 seconds
}
}
export async function getStaticPaths() {
const products = await fetchAllProducts()
return {
paths: products.map(p => ({ params: { id: p.id } })),
fallback: 'blocking'
}
}Performance Monitoring Solutions
Web Vitals Monitoring:
// Using web-vitals library
import { getCLS, getFID, getLCP } from 'web-vitals'
function sendToAnalytics(metric) {
console.log(metric)
// Send to monitoring system
}
getCLS(sendToAnalytics)
getFID(sendToAnalytics)
getLCP(sendToAnalytics)Lighthouse Optimization Recommendations:
- Priority Metrics:
- First Contentful Paint (FCP).
- Largest Contentful Paint (LCP).
- Cumulative Layout Shift (CLS).
- Optimization Directions:
- Inline critical CSS.
- Lazy-load images.
- Preconnect critical third-party resources.
CI/CD Practices
GitHub Actions Example:
# .github/workflows/deploy.yml
name: Deploy to Production
on:
push:
branches: [ main ]
jobs:
build-and-deploy:
runs-on: ubuntu-latest
steps:
- uses: actions/checkout@v2
- uses: actions/setup-node@v2
with:
node-version: '16'
- run: npm ci
- run: npm run build
- uses: peaceiris/actions-gh-pages@v3
with:
github_token: ${{ secrets.GITHUB_TOKEN }}
publish_dir: ./distDockerization Configuration:
# Dockerfile
FROM node:16-alpine as builder
WORKDIR /app
COPY package*.json ./
RUN npm ci
COPY . .
RUN npm run build
FROM nginx:alpine
COPY --from=builder /app/dist /usr/share/nginx/html
COPY nginx.conf /etc/nginx/conf.d/default.conf
EXPOSE 80
CMD ["nginx", "-g", "daemon off;"]By implementing the above architecture design and engineering practices, you can build high-performance, maintainable, and scalable React applications. The key is to select appropriate technical solutions based on project scale and team characteristics, while continuously monitoring performance metrics and user experience during development.



