# 架构模式文档
$ cat > architecture_patterns.md << 'EOF' # 软件架构模式 ## 1. 分层架构 - 表示层：用户界面 - 业务逻辑层：业务处理 - 数据访问层：数据操作 - 数据存储层：数据存储 ## 2. 微服务架构 - 服务拆分：按业务领域拆分 - 服务通信：RESTful API、消息队列 - 服务发现：Consul、Eureka - 服务治理：Hystrix、Sentinel ## 3. 事件驱动架构 - 事件发布：事件源 - 事件处理：事件处理器 - 事件存储：事件存储 - 事件流：事件流处理 ## 4. 领域驱动设计 - 领域模型：核心业务模型 - 聚合根：领域对象的根 - 领域服务：领域逻辑 - 仓储：数据访问 ## 5. 六边形架构 - 核心业务逻辑 - 输入适配器：API、消息 - 输出适配器：数据库、消息 - 端口：接口定义 EOF # 查看架构模式 $ cat architecture_patterns.md # 软件架构模式 ## 1. 分层架构 - 表示层：用户界面 - 业务逻辑层：业务处理 - 数据访问层：数据操作 - 数据存储层：数据存储 ## 2. 微服务架构 - 服务拆分：按业务领域拆分 - 服务通信：RESTful API、消息队列 - 服务发现：Consul、Eureka - 服务治理：Hystrix、Sentinel ## 3. 事件驱动架构 - 事件发布：事件源 - 事件处理：事件处理器 - 事件存储：事件存储 - 事件流：事件流处理 ## 4. 领域驱动设计 - 领域模型：核心业务模型 - 聚合根：领域对象的根 - 领域服务：领域逻辑 - 仓储：数据访问 ## 5. 六边形架构 - 核心业务逻辑 - 输入适配器：API、消息 - 输出适配器：数据库、消息 - 端口：接口定义

# 创建微服务架构示例
$ mkdir -p microservices/{user-service,order-service,product-service,api-gateway}

# 初始化用户服务
$ cd microservices/user-service
$ npm init -y
$ npm install express mongoose

# 创建用户服务代码
$ cat > app.js << 'EOF' const express = require('express'); const mongoose = require('mongoose'); const app = express(); const port = 3001; // 连接数据库 mongoose.connect('mongodb://fgedudb:27017/user-service', { useNewUrlParser: true, useUnifiedTopology: true }); // 定义用户模型 const User = mongoose.model('User', new mongoose.Schema({ name: String, email: String, password: String })); // 路由 app.get('/users', async (req, res) => {
const users = await User.find();
res.json(users);
});

app.post(‘/users’, async (req, res) => {
const user = new User(req.body);
await user.save();
res.json(user);
});

app.listen(port, () => {
console.log(`User service listening at http://fgedudb:${port}`);
});
EOF

# 初始化订单服务
$ cd ../order-service
$ npm init -y
$ npm install express mongoose

# 创建订单服务代码
$ cat > app.js << 'EOF' const express = require('express'); const mongoose = require('mongoose'); const app = express(); const port = 3002; // 连接数据库 mongoose.connect('mongodb://fgedudb:27017/order-service', { useNewUrlParser: true, useUnifiedTopology: true }); // 定义订单模型 const Order = mongoose.model('Order', new mongoose.Schema({ userId: String, productId: String, quantity: Number, total: Number })); // 路由 app.get('/orders', async (req, res) => {
const orders = await Order.find();
res.json(orders);
});

app.post(‘/orders’, async (req, res) => {
const order = new Order(req.body);
await order.save();
res.json(order);
});

app.listen(port, () => {
console.log(`Order service listening at http://fgedudb:${port}`);
});
EOF

# 初始化产品服务
$ cd ../product-service
$ npm init -y
$ npm install express mongoose

# 创建产品服务代码
$ cat > app.js << 'EOF' const express = require('express'); const mongoose = require('mongoose'); const app = express(); const port = 3003; // 连接数据库 mongoose.connect('mongodb://fgedudb:27017/product-service', { useNewUrlParser: true, useUnifiedTopology: true }); // 定义产品模型 const Product = mongoose.model('Product', new mongoose.Schema({ name: String, price: Number, description: String })); // 路由 app.get('/products', async (req, res) => {
const products = await Product.find();
res.json(products);
});

app.post(‘/products’, async (req, res) => {
const product = new Product(req.body);
await product.save();
res.json(product);
});

app.listen(port, () => {
console.log(`Product service listening at http://fgedudb:${port}`);
});
EOF

# 初始化API网关
$ cd ../api-gateway
$ npm init -y
$ npm install express http-proxy-middleware

# 创建API网关代码
$ cat > app.js << 'EOF' const express = require('express'); const { createProxyMiddleware } = require('http-proxy-middleware'); const app = express(); const port = 3000; // 代理配置 app.use('/api/users', createProxyMiddleware({ target: 'http://fgedudb:3001', changeOrigin: true })); app.use('/api/orders', createProxyMiddleware({ target: 'http://fgedudb:3002', changeOrigin: true })); app.use('/api/products', createProxyMiddleware({ target: 'http://fgedudb:3003', changeOrigin: true })); app.listen(port, () => {
console.log(`API gateway listening at http://fgedudb:${port}`);
});
EOF

# 启动服务
$ cd ..
$ docker-compose up -d

# 创建云原生架构示例
$ mkdir -p cloud-native/{frontend,backend,db}

# 创建Dockerfile
$ cat > cloud-native/Dockerfile << 'EOF' FROM node:14-alpine WORKDIR /app COPY package*.json ./ RUN npm install COPY . . EXPOSE 3000 CMD ["npm", "start"] EOF # 创建docker-compose.yml $ cat > cloud-native/docker-compose.yml << 'EOF' version: '3' services: frontend: build: ./frontend ports: - "3000:3000" depends_on: - backend backend: build: ./backend ports: - "8080:8080" depends_on: - db db: image: mongo:4.4 ports: - "27017:27017" volumes: - mongo-data:/data/db volumes: mongo-data: EOF # 初始化前端项目 $ cd cloud-native/frontend $ npm init -y $ npm install react react-dom react-scripts # 创建前端代码 $ cat > src/App.js << 'EOF' import React, { useState, useEffect } from 'react'; function App() { const [data, setData] = useState([]); useEffect(() => {
fetch(‘http://fgedudb:8080/api/data’)
.then(response => response.json())
.then(data => setData(data));
}, []);

return (

);
}

export default App;
EOF

# 初始化后端项目
$ cd ../backend
$ npm init -y
$ npm install express mongoose

# 创建后端代码
$ cat > app.js << 'EOF' const express = require('express'); const mongoose = require('mongoose'); const app = express(); const port = 8080; // 连接数据库 mongoose.connect('mongodb://db:27017/cloud-native', { useNewUrlParser: true, useUnifiedTopology: true }); // 定义数据模型 const Item = mongoose.model('Item', new mongoose.Schema({ name: String, description: String })); // 路由 app.get('/api/data', async (req, res) => {
const items = await Item.find();
res.json(items);
});

app.post(‘/api/data’, async (req, res) => {
const item = new Item(req.body);
await item.save();
res.json(item);
});

app.listen(port, () => {
console.log(`Backend service listening at http://fgedudb:${port}`);
});
EOF

# 构建和启动服务
$ cd ..
$ docker-compose up -d

# 创建安全架构示例
$ mkdir -p security-architecture

# 初始化项目
$ cd security-architecture
$ npm init -y
$ npm install express passport passport-jwt jsonwebtoken bcrypt

# 创建安全配置
$ cat > config.js << 'EOF' module.exports = { jwtSecret: 'your-secret-key', jwtExpiration: '1h' }; EOF # 创建用户模型 $ cat > models/User.js << 'EOF' const mongoose = require('mongoose'); const bcrypt = require('bcrypt'); const UserSchema = new mongoose.Schema({ username: String, password: String }); UserSchema.pre('save', async function(next) { if (this.isModified('password')) { this.password = await bcrypt.hash(this.password, 10); } next(); }); UserSchema.methods.comparePassword = async function(password) { return await bcrypt.compare(password, this.password); }; module.exports = mongoose.model('User', UserSchema); EOF # 创建认证中间件 $ cat > middleware/auth.js << 'EOF' const passport = require('passport'); const JwtStrategy = require('passport-jwt').Strategy; const ExtractJwt = require('passport-jwt').ExtractJwt; const config = require('../config'); const User = require('../models/User'); const opts = { jwtFromRequest: ExtractJwt.fromAuthHeaderAsBearerToken(), secretOrKey: config.jwtSecret }; passport.use(new JwtStrategy(opts, async (jwt_payload, done) => {
try {
const user = await User.findById(jwt_payload.id);
if (user) {
return done(null, user);
} else {
return done(null, false);
}
} catch (error) {
return done(error, false);
}
}));

module.exports = passport;
EOF

# 创建主应用
$ cat > app.js << 'EOF' const express = require('express'); const mongoose = require('mongoose'); const passport = require('./middleware/auth'); const jwt = require('jsonwebtoken'); const config = require('./config'); const User = require('./models/User'); const app = express(); const port = 3000; app.use(express.json()); app.use(passport.initialize()); // 连接数据库 mongoose.connect('mongodb://fgedudb:27017/security-architecture', { useNewUrlParser: true, useUnifiedTopology: true }); // 注册路由 app.post('/api/register', async (req, res) => {
const user = new User(req.body);
await user.save();
res.json({ message: ‘User registered successfully’ });
});

// 登录路由
app.post(‘/api/login’, async (req, res) => {
const { username, password } = req.body;
const user = await User.findOne({ username });
if (!user) {
return res.status(401).json({ message: ‘Invalid credentials’ });
}
const isMatch = await user.comparePassword(password);
if (!isMatch) {
return res.status(401).json({ message: ‘Invalid credentials’ });
}
const token = jwt.sign({ id: user._id }, config.jwtSecret, { expiresIn: config.jwtExpiration });
res.json({ token });
});

// 受保护的路由
app.get(‘/api/protected’, passport.authenticate(‘jwt’, { session: false }), (req, res) => {
res.json({ message: ‘Protected route accessed successfully’ });
});

app.listen(port, () => {
console.log(`Security architecture example listening at http://fgedudb:${port}`);
});
EOF

# 启动服务
$ node app.js

# 创建可扩展性设计示例
$ mkdir -p scalability-design

# 初始化项目
$ cd scalability-design
$ npm init -y
$ npm install express redis

# 创建主应用
$ cat > app.js << 'EOF' const express = require('express'); const redis = require('redis'); const app = express(); const port = 3000; // 连接Redis const client = redis.createClient(); client.on('error', (err) => {
console.error(‘Redis error:’, err);
});

// 中间件
app.use(express.json());

// 缓存中间件
const cache = (req, res, next) => {
const key = req.url;
client.get(key, (err, data) => {
if (err) throw err;
if (data) {
res.json(JSON.parse(data));
} else {
next();
}
});
};

// 模拟数据
const products = [
{ id: 1, name: ‘Product 1’, price: 100 },
{ id: 2, name: ‘Product 2’, price: 200 },
{ id: 3, name: ‘Product 3’, price: 300 }
];

// 路由
app.get(‘/api/products’, cache, (req, res) => {
// 模拟数据库查询延迟
setTimeout(() => {
client.setex(req.url, 60, JSON.stringify(products));
res.json(products);
}, 1000);
});

app.get(‘/api/products/:id’, cache, (req, res) => {
const { id } = req.params;
// 模拟数据库查询延迟
setTimeout(() => {
const product = products.find(p => p.id === parseInt(id));
if (product) {
client.setex(req.url, 60, JSON.stringify(product));
res.json(product);
} else {
res.status(404).json({ message: ‘Product not found’ });
}
}, 500);
});

app.listen(port, () => {
console.log(`Scalability design example listening at http://fgedudb:${port}`);
});
EOF

# 启动服务
$ node app.js

# 创建架构实现示例
$ mkdir -p architecture-implementation

# 初始化项目
$ cd architecture-implementation
$ npm init -y
$ npm install express mocha chai supertest

# 创建主应用
$ cat > app.js << 'EOF' const express = require('express'); const app = express(); const port = 3000; app.use(express.json()); // 路由 app.get('/api/health', (req, res) => {
res.json({ status: ‘ok’ });
});

app.get(‘/api/users’, (req, res) => {
res.json([
{ id: 1, name: ‘User 1’ },
{ id: 2, name: ‘User 2’ }
]);
});

app.post(‘/api/users’, (req, res) => {
res.json({ id: 3, name: req.body.name });
});

app.listen(port, () => {
console.log(`Architecture implementation example listening at http://fgedudb:${port}`);
});

module.exports = app;
EOF

# 创建测试文件
$ cat > test/app.test.js << 'EOF' const request = require('supertest'); const app = require('../app'); const chai = require('chai'); const expect = chai.expect; describe('API tests', () => {
it(‘should return health status’, (done) => {
request(app)
.get(‘/api/health’)
.expect(200)
.end((err, res) => {
expect(res.body.status).to.equal(‘ok’);
done();
});
});

it(‘should return users’, (done) => {
request(app)
.get(‘/api/users’)
.expect(200)
.end((err, res) => {
expect(res.body).to.be.an(‘array’);
expect(res.body.length).to.equal(2);
done();
});
});

it(‘should create a user’, (done) => {
request(app)
.post(‘/api/users’)
.send({ name: ‘User 3’ })
.expect(200)
.end((err, res) => {
expect(res.body.id).to.equal(3);
expect(res.body.name).to.equal(‘User 3’);
done();
});
});
});
EOF

# 运行测试
$ npm test

# 部署到Docker
$ cat > Dockerfile << 'EOF' FROM node:14-alpine WORKDIR /app COPY package*.json ./ RUN npm install COPY . . EXPOSE 3000 CMD ["node", "app.js"] EOF $ docker build -t architecture-implementation . $ docker run -p 3000:3000 architecture-implementation