Java 代码实现高性能分布式酒店人员管理系统
技术选型
- 后端：Spring Boot (Java)
- 前端：React.js
- 数据库：MySQL
- 消息队列：RabbitMQ
- 缓存：Redis
- 容器化：Docker
- 监控：Prometheus + Grafana
用户管理模块
用户注册 用户登录 权限管理
@RestController
@RequestMapping("/api/users")
public class UserController {
@Autowired
private UserService userService;
@PostMapping("/register")
public ResponseEntity<?> registerUser(@RequestBody User user) {
userService.registerUser(user);
return ResponseEntity.ok("User registered successfully");
}
@PostMapping("/login")
public ResponseEntity<?> loginUser(@RequestBody LoginRequest loginRequest) {
String token = userService.loginUser(loginRequest);
return ResponseEntity.ok(new AuthResponse(token));
}
}
@Service
public class UserService {
@Autowired
private UserRepository userRepository;
@Autowired
private JwtTokenProvider jwtTokenProvider;
public void registerUser(User user) {
userRepository.save(user);
}
public String loginUser(LoginRequest loginRequest) {
User user = userRepository.findByUsername(loginRequest.getUsername());
if (user != null && user.getPassword().equals(loginRequest.getPassword())) {
return jwtTokenProvider.createToken(user.getUsername());
}
throw new RuntimeException("Invalid credentials");
}
}
@Repository
public interface UserRepository extends JpaRepository<User, Long> {
User findByUsername(String username);
}
员工管理模块
员工信息管理 员工排班 员工考勤
@RestController
@RequestMapping("/api/employees")
public class EmployeeController {
@Autowired
private EmployeeService employeeService;
@PostMapping("/add")
public ResponseEntity<?> addEmployee(@RequestBody Employee employee) {
employeeService.addEmployee(employee);
return ResponseEntity.ok("Employee added successfully");
}
@GetMapping("/{id}")
public ResponseEntity<?> getEmployee(@PathVariable Long id) {
Employee employee = employeeService.getEmployeeById(id);
return ResponseEntity.ok(employee);
}
@PutMapping("/update")
public ResponseEntity<?> updateEmployee(@RequestBody Employee employee) {
employeeService.updateEmployee(employee);
return ResponseEntity.ok("Employee updated successfully");
}
@DeleteMapping("/{id}")
public ResponseEntity<?> deleteEmployee(@PathVariable Long id) {
employeeService.deleteEmployee(id);
return ResponseEntity.ok("Employee deleted successfully");
}
}
@Service
public class EmployeeService {
@Autowired
private EmployeeRepository employeeRepository;
public void addEmployee(Employee employee) {
employeeRepository.save(employee);
}
public Employee getEmployeeById(Long id) {
return employeeRepository.findById(id).orElseThrow(() -> new RuntimeException("Employee not found"));
}
public void updateEmployee(Employee employee) {
employeeRepository.save(employee);
}
public void deleteEmployee(Long id) {
employeeRepository.deleteById(id);
}
}
@Repository
public interface EmployeeRepository extends JpaRepository<Employee, Long> {}
房间管理模块
房间信息管理 房间预订管理
@RestController
@RequestMapping("/api/rooms")
public class RoomController {
@Autowired
private RoomService roomService;
@PostMapping("/add")
public ResponseEntity<?> addRoom(@RequestBody Room room) {
roomService.addRoom(room);
return ResponseEntity.ok("Room added successfully");
}
@GetMapping("/{id}")
public ResponseEntity<?> getRoom(@PathVariable Long id) {
Room room = roomService.getRoomById(id);
return ResponseEntity.ok(room);
}
@PutMapping("/update")
public ResponseEntity<?> updateRoom(@RequestBody Room room) {
roomService.updateRoom(room);
return ResponseEntity.ok("Room updated successfully");
}
@DeleteMapping("/{id}")
public ResponseEntity<?> deleteRoom(@PathVariable Long id) {
roomService.deleteRoom(id);
return ResponseEntity.ok("Room deleted successfully");
}
}
@Service
public class RoomService {
@Autowired
private RoomRepository roomRepository;
public void addRoom(Room room) {
roomRepository.save(room);
}
public Room getRoomById(Long id) {
return roomRepository.findById(id).orElseThrow(() -> new RuntimeException("Room not found"));
}
public void updateRoom(Room room) {
roomRepository.save(room);
}
public void deleteRoom(Long id) {
roomRepository.deleteById(id);
}
}
@Repository
public interface RoomRepository extends JpaRepository<Room, Long> {}
通知和消息模块
消息推送 员工通知
@Component
public class MessagePublisher {
@Autowired
private RabbitTemplate rabbitTemplate;
@Value("${rabbitmq.exchange}")
private String exchange;
public void sendMessage(String routingKey, String message) {
rabbitTemplate.convertAndSend(exchange, routingKey, message);
}
}
@RestController
@RequestMapping("/api/messages")
public class MessageController {
@Autowired
private MessagePublisher messagePublisher;
@PostMapping("/send")
public ResponseEntity<?> sendMessage(@RequestBody MessageRequest messageRequest) {
messagePublisher.sendMessage(messageRequest.getRoutingKey(), messageRequest.getMessage());
return ResponseEntity.ok("Message sent successfully");
}
}
日志和监控模块
系统日志 性能监控
@RestController
@RequestMapping("/api/logs")
public class LogController {
@Autowired
private LogService logService;
@GetMapping("/get")
public ResponseEntity<?> getLogs() {
List<Log> logs = logService.getLogs();
return ResponseEntity.ok(logs);
}
}
@Service
public class LogService {
@Autowired
private LogRepository logRepository;
public List<Log> getLogs() {
return logRepository.findAll();
}
}
@Repository
public interface LogRepository extends JpaRepository<Log, Long> {}
数据库管理模块
数据存储和检索 数据备份和恢复
@Entity
public class User {
@Id
@GeneratedValue(strategy = GenerationType.IDENTITY)
private Long id;
private String username;
private String password;
// Getters and Setters
}
@Entity
public class Employee {
@Id
@GeneratedValue(strategy = GenerationType.IDENTITY)
private Long id;
private String name;
private String position;
private String department;
// Getters and Setters
}
@Entity
public class Room {
@Id
@GeneratedValue(strategy = GenerationType.IDENTITY)
private Long id;
private String number;
private String type;
private Double price;
// Getters and Setters
}
@Entity
public class Log {
@Id
@GeneratedValue(strategy = GenerationType.IDENTITY)
private Long id;
private String message;
private LocalDateTime timestamp;
// Getters and Setters
}
Python 代码实现高性能分布式酒店人员管理系统
用户管理模块
用户注册 用户登录 权限管理
from fastapi import FastAPI
from fastapi.middleware.cors import CORSMiddleware
from routers import users, employees, rooms, notifications, logs
app = FastAPI()
app.add_middleware(
CORSMiddleware,
allow_origins=["*"],
allow_credentials=True,
allow_methods=["*"],
allow_headers=["*"],
)
app.include_router(users.router)
app.include_router(employees.router)
app.include_router(rooms.router)
app.include_router(notifications.router)
app.include_router(logs.router)
@app.get("/")
def read_root():
return {"message": "Welcome to the Hotel Management System"}
员工管理模块
员工信息管理 员工排班 员工考勤
from fastapi import APIRouter, Depends, HTTPException
from sqlalchemy.orm import Session
from models import Employee, get_db
from schemas import EmployeeCreate, EmployeeUpdate
router = APIRouter(prefix="/employees", tags=["employees"])
@router.post("/add")
def add_employee(employee: EmployeeCreate, db: Session = Depends(get_db)):
new_employee = Employee(**employee.dict())
db.add(new_employee)
db.commit()
db.refresh(new_employee)
return {"message": "Employee added successfully"}
@router.get("/{id}")
def get_employee(id: int, db: Session = Depends(get_db)):
employee = db.query(Employee).filter(Employee.id == id).first()
if employee is None:
raise HTTPException(status_code=404, detail="Employee not found")
return employee
@router.put("/update")
def update_employee(employee: EmployeeUpdate, db: Session = Depends(get_db)):
db_employee = db.query(Employee).filter(Employee.id == employee.id).first()
if db_employee is None:
raise HTTPException(status_code=404, detail="Employee not found")
for var, value in vars(employee).items():
setattr(db_employee, var, value) if value else None
db.add(db_employee)
db.commit()
db.refresh(db_employee)
return {"message": "Employee updated successfully"}
@router.delete("/{id}")
def delete_employee(id: int, db: Session = Depends(get_db)):
employee = db.query(Employee).filter(Employee.id == id).first()
if employee is None:
raise HTTPException(status_code=404, detail="Employee not found")
db.delete(employee)
db.commit()
return {"message": "Employee deleted successfully"}
房间管理模块
房间信息管理 房间预订管理
from fastapi import APIRouter, Depends, HTTPException
from sqlalchemy.orm import Session
from models import Room, get_db
from schemas import RoomCreate, RoomUpdate
router = APIRouter(prefix="/rooms", tags=["rooms"])
@router.post("/add")
def add_room(room: RoomCreate, db: Session = Depends(get_db)):
new_room = Room(**room.dict())
db.add(new_room)
db.commit()
db.refresh(new_room)
return {"message": "Room added successfully"}
@router.get("/{id}")
def get_room(id: int, db: Session = Depends(get_db)):
room = db.query(Room).filter(Room.id == id).first()
if room is None:
raise HTTPException(status_code=404, detail="Room not found")
return room
@router.put("/update")
def update_room(room: RoomUpdate, db: Session = Depends(get_db)):
db_room = db.query(Room).filter(Room.id == room.id).first()
if db_room is None:
raise HTTPException(status_code=404, detail="Room not found")
for var, value in vars(room).items():
setattr(db_room, var, value) if value else None
db.add(db_room)
db.commit()
db.refresh(db_room)
return {"message": "Room updated successfully"}
@router.delete("/{id}")
def delete_room(id: int, db: Session = Depends(get_db)):
room = db.query(Room).filter(Room.id == id).first()
if room is None:
raise HTTPException(status_code=404, detail="Room not found")
db.delete(room)
db.commit()
return {"message": "Room deleted successfully"}
