## 案例1：人力资源管理系统

### 业务需求
– 员工信息管理：添加、修改、删除员工信息
– 部门管理：管理部门信息
– 薪资管理：管理员工薪资
– 考勤管理：管理员工考勤
– 报表生成：生成各种报表

### 技术栈
– 前端：React.js
– 后端：Spring Boot
– 数据库：Oracle 26ai
– API：RESTful API

### 实施步骤
1. 设计数据库结构：创建员工、部门、薪资、考勤表
2. 开发后端API：使用Spring Boot开发RESTful API
3. 开发前端应用：使用React.js开发前端界面
4. 集成测试：测试系统功能
5. 部署系统：部署到生产环境

### 数据库设计
SQL> CREATE TABLE departments (
department_id NUMBER PRIMARY KEY,
department_name VARCHAR2(100),
location VARCHAR2(100)
);

SQL> CREATE TABLE employees (
employee_id NUMBER PRIMARY KEY,
first_name VARCHAR2(50),
last_name VARCHAR2(50),
email VARCHAR2(100),
hire_date DATE,
job_id VARCHAR2(10),
salary NUMBER,
department_id NUMBER REFERENCES departments(department_id)
);

SQL> CREATE TABLE salaries (
salary_id NUMBER PRIMARY KEY,
employee_id NUMBER REFERENCES employees(employee_id),
salary NUMBER,
effective_date DATE
);

SQL> CREATE TABLE attendance (
attendance_id NUMBER PRIMARY KEY,
employee_id NUMBER REFERENCES employees(employee_id),
attendance_date DATE,
status VARCHAR2(20)
);

### 后端API开发
@RestController
@RequestMapping(“/api/employees”)
public class EmployeeController {
@Autowired
private EmployeeService employeeService;

@GetMapping
public List getAllEmployees() {
return employeeService.getAllEmployees();
}

@GetMapping(“/{id}”)
public Employee getEmployeeById(@PathVariable Long id) {
return employeeService.getEmployeeById(id);
}

@PostMapping
public Employee createEmployee(@RequestBody Employee employee) {
return employeeService.createEmployee(employee);
}

@PutMapping(“/{id}”)
public Employee updateEmployee(@PathVariable Long id, @RequestBody Employee employee) {
return employeeService.updateEmployee(id, employee);
}

@DeleteMapping(“/{id}”)
public void deleteEmployee(@PathVariable Long id) {
employeeService.deleteEmployee(id);
}
}

## 案例2：电子商务系统

### 业务需求
– 产品管理：管理产品信息
– 订单管理：管理订单信息
– 客户管理：管理客户信息
– 支付管理：管理支付信息
– 物流管理：管理物流信息

### 技术栈
– 前端：Vue.js
– 后端：Node.js + Express
– 数据库：Oracle 26ai
– API：RESTful API

### 实施步骤
1. 设计数据库结构：创建产品、订单、客户、支付、物流表
2. 开发后端API：使用Node.js + Express开发RESTful API
3. 开发前端应用：使用Vue.js开发前端界面
4. 集成测试：测试系统功能
5. 部署系统：部署到生产环境

### 数据库设计
SQL> CREATE TABLE customers (
customer_id NUMBER PRIMARY KEY,
first_name VARCHAR2(50),
last_name VARCHAR2(50),
email VARCHAR2(100),
phone VARCHAR2(20),
address VARCHAR2(200)
);

SQL> CREATE TABLE products (
product_id NUMBER PRIMARY KEY,
product_name VARCHAR2(100),
description VARCHAR2(500),
price NUMBER,
stock NUMBER
);

SQL> CREATE TABLE orders (
order_id NUMBER PRIMARY KEY,
customer_id NUMBER REFERENCES customers(customer_id),
order_date DATE,
total_amount NUMBER,
status VARCHAR2(20)
);

SQL> CREATE TABLE order_items (
order_item_id NUMBER PRIMARY KEY,
order_id NUMBER REFERENCES orders(order_id),
product_id NUMBER REFERENCES products(product_id),
quantity NUMBER,
unit_price NUMBER
);

SQL> CREATE TABLE payments (
payment_id NUMBER PRIMARY KEY,
order_id NUMBER REFERENCES orders(order_id),
payment_date DATE,
amount NUMBER,
payment_method VARCHAR2(50),
status VARCHAR2(20)
);

### 后端API开发
const express = require(‘express’);
const router = express.Router();
const oracle = require(‘oracledb’);

router.get(‘/products’, async (req, res) => {
try {
const connection = await oracle.getConnection({
user: ‘scott’,
password: ‘tiger’,
connectString: ‘localhost:1521/ORCL’
});
const result = await connection.execute(‘SELECT * FROM products’);
await connection.close();
res.json(result.rows);
} catch (err) {
res.status(500).json({ error: err.message });
}
});

router.post(‘/orders’, async (req, res) => {
try {
const connection = await oracle.getConnection({
user: ‘scott’,
password: ‘tiger’,
connectString: ‘localhost:1521/ORCL’
});
const { customer_id, total_amount } = req.body;
const result = await connection.execute(
‘INSERT INTO orders (order_id, customer_id, order_date, total_amount, status) VALUES (orders_seq.nextval, :customer_id, SYSDATE, :total_amount, :status) RETURNING order_id INTO :order_id’,
{ customer_id, total_amount, status: ‘PENDING’, order_id: { type: oracle.NUMBER, dir: oracle.BIND_OUT } }
);
await connection.commit();
await connection.close();
res.json({ order_id: result.outBinds.order_id[0] });
} catch (err) {
res.status(500).json({ error: err.message });
}
});

module.exports = router;

# 环境配置
– 服务器配置：配置服务器硬件和软件
– 数据库配置：配置Oracle 26ai数据库
– 网络配置：配置网络连接
– 安全配置：配置安全措施

# 应用部署
– 后端部署：部署后端应用
– 前端部署：部署前端应用
– API部署：部署API服务
– 服务集成：集成各个服务

# 测试验证
– 功能测试：测试应用功能
– 性能测试：测试应用性能
– 安全测试：测试应用安全性
– 兼容性测试：测试应用兼容性

# 监控配置
– 应用监控：监控应用运行状态
– 数据库监控：监控数据库性能
– 服务器监控：监控服务器状态
– 告警配置：配置告警机制

# 示例：使用Docker部署应用

# 1. 创建Dockerfile
FROM openjdk:11-jdk-slim
WORKDIR /app
COPY target/spring-boot-oracle.jar app.jar
EXPOSE 8080
ENTRYPOINT [“java”, “-jar”, “app.jar”]

# 2. 构建Docker镜像
$ docker build -t spring-boot-oracle .

# 3. 运行Docker容器
$ docker run -d -p 8080:8080 –name spring-boot-oracle spring-boot-oracle

# 4. 测试应用
$ curl http://localhost:8080/api/employees

# 示例：使用Kubernetes部署应用

# 1. 创建Deployment
apiVersion: apps/v1
kind: Deployment
metadata:
name: spring-boot-oracle
spec:
replicas: 3
selector:
matchLabels:
app: spring-boot-oracle
template:
metadata:
labels:
app: spring-boot-oracle
spec:
containers:
– name: spring-boot-oracle
image: spring-boot-oracle
ports:
– containerPort: 8080

# 2. 创建Service
apiVersion: v1
kind: Service
metadata:
name: spring-boot-oracle
spec:
selector:
app: spring-boot-oracle
ports:
– port: 8080
targetPort: 8080
type: LoadBalancer

# 3. 部署到Kubernetes
$ kubectl apply -f deployment.yaml
$ kubectl apply -f service.yaml

# 4. 测试应用
$ curl http://$(kubectl get service spring-boot-oracle -o jsonpath='{.status.loadBalancer.ingress[0].ip}’):8080/api/employees