写一个基于ssm的汽车租赁系统的订单模块的实现

数据库设计

订单表(order)：

| 字段名 | 数据类型 | 备注 | | ------------ | ------------ | ---------------------- | | id | int | 主键，自增长 | | customer_id | int | 外键，客户id | | car_id | int | 外键，汽车id | | start_time | datetime | 租车时间 | | end_time | datetime | 还车时间 | | rent_price | decimal(10,2)| 租金 | | penalty | decimal(10,2)| 违约金 | | actual_price | decimal(10,2)| 实际支付金额 | | status | tinyint | 订单状态（0-未还车，1-已还车） |

DAO层实现

OrderMapper.xml文件：

<!-- 添加订单 -->
<insert id="addOrder" parameterType="Order">
    insert into order(customer_id, car_id, start_time, end_time, rent_price, penalty, actual_price, status)
    values(#{customer.id}, #{car.id}, #{startTime}, #{endTime}, #{rentPrice}, #{penalty}, #{actualPrice}, #{status})
</insert>

<!-- 根据id查询订单 -->
<select id="getOrderById" parameterType="int" resultType="Order">
    select o.id, o.customer_id, o.car_id, o.start_time, o.end_time, o.rent_price, o.penalty, o.actual_price, o.status,
           c.name as customerName, c.phone as customerPhone,
           ca.brand as carBrand, ca.model as carModel, ca.price as carPrice
    from `order` o
    left join customer c on o.customer_id = c.id
    left join car ca on o.car_id = ca.id
    where o.id = #{id}
</select>

<!-- 根据客户id查询订单 -->
<select id="getOrdersByCustomerId" parameterType="int" resultType="Order">
    select o.id, o.customer_id, o.car_id, o.start_time, o.end_time, o.rent_price, o.penalty, o.actual_price, o.status,
           c.name as customerName, c.phone as customerPhone,
           ca.brand as carBrand, ca.model as carModel, ca.price as carPrice
    from `order` o
    left join customer c on o.customer_id = c.id
    left join car ca on o.car_id = ca.id
    where o.customer_id = #{customerId}
</select>

<!-- 修改订单状态 -->
<update id="updateOrderStatus" parameterType="Order">
    update `order` set status = #{status} where id = #{id}
</update>

<!-- 删除订单 -->
<delete id="deleteOrder" parameterType="int">
    delete from `order` where id = #{id}
</delete>

OrderMapper接口：

@Repository
public interface OrderMapper {
    void addOrder(Order order);
    Order getOrderById(int id);
    List<Order> getOrdersByCustomerId(int customerId);
    void updateOrderStatus(Order order);
    void deleteOrder(int id);
}

Service层实现

OrderService接口：

public interface OrderService {
    void addOrder(Order order);
    Order getOrderById(int id);
    List<Order> getOrdersByCustomerId(int customerId);
    void returnCar(int id, Date endTime);
    void deleteOrder(int id);
}

OrderServiceImpl实现：

@Service
public class OrderServiceImpl implements OrderService {

    private OrderMapper orderMapper;
    private CarMapper carMapper;

    @Autowired
    public OrderServiceImpl(OrderMapper orderMapper, CarMapper carMapper) {
        this.orderMapper = orderMapper;
        this.carMapper = carMapper;
    }

    @Override
    public void addOrder(Order order) {
        // 计算租金
        BigDecimal rentPrice = order.getCar().getPrice()
                .multiply(new BigDecimal(order.getEndTime().getTime() - order.getStartTime().getTime()))
                .divide(new BigDecimal(24 * 60 * 60 * 1000), 2, BigDecimal.ROUND_HALF_UP);
        order.setRentPrice(rentPrice);

        orderMapper.addOrder(order);

        // 修改汽车状态为已租
        Car car = order.getCar();
        car.setStatus(1);
        carMapper.updateCar(car);
    }

    @Override
    public Order getOrderById(int id) {
        return orderMapper.getOrderById(id);
    }

    @Override
    public List<Order> getOrdersByCustomerId(int customerId) {
        return orderMapper.getOrdersByCustomerId(customerId);
    }

    @Override
    public void returnCar(int id, Date endTime) {
        Order order = getOrderById(id);
        if(order == null || order.getStatus() == 1){
            throw new RuntimeException("订单不存在或已还车");
        }

        // 计算租金和违约金
        BigDecimal rentPrice = order.getRentPrice();
        BigDecimal penalty = BigDecimal.ZERO;
        if(endTime.after(order.getEndTime())){
            long days = (endTime.getTime() - order.getEndTime().getTime()) / (24 * 60 * 60 * 1000) + 1;
            penalty = order.getCar().getPrice().multiply(new BigDecimal(days)).multiply(new BigDecimal(0.1));
        }
        BigDecimal actualPrice = rentPrice.add(penalty);
        order.setEndTime(endTime);
        order.setPenalty(penalty);
        order.setActualPrice(actualPrice);
        order.setStatus(1);

        orderMapper.updateOrderStatus(order);

        // 修改汽车状态为未租
        Car car = order.getCar();
        car.setStatus(0);
        carMapper.updateCar(car);
    }

    @Override
    public void deleteOrder(int id) {
        orderMapper.deleteOrder(id);
    }
}

Controller层实现

OrderController实现：

@Controller
@RequestMapping("/order")
public class OrderController {

    private OrderService orderService;

    @Autowired
    public OrderController(OrderService orderService) {
        this.orderService = orderService;
    }

    @RequestMapping("/add")
    public String addOrder(Order order){
        orderService.addOrder(order);
        return "redirect:/customer/" + order.getCustomer().getId() + "/orders";
    }

    @RequestMapping("/{id}")
    @ResponseBody
    public Order getOrderById(@PathVariable int id){
        return orderService.getOrderById(id);
    }

    @RequestMapping("/customer/{customerId}")
    @ResponseBody
    public List<Order> getOrdersByCustomerId(@PathVariable int customerId){
        return orderService.getOrdersByCustomerId(customerId);
    }

    @RequestMapping("/{id}/return")
    public String returnCar(@PathVariable int id, Date endTime){
        orderService.returnCar(id, endTime);
        return "redirect:/customer/" + orderService.getOrderById(id).getCustomer().getId() + "/orders";
    }

    @RequestMapping("/{id}/delete")
    public String deleteOrder(@PathVariable int id){
        int customerId = orderService.getOrderById(id).getCustomer().getId();
        orderService.deleteOrder(id);
        return "redirect:/customer/" + customerId + "/orders";
    }
}

以上就是基于SSM的汽车租赁系统订单模块的实现。