国产一级a片免费看高清,亚洲熟女中文字幕在线视频,黄三级高清在线播放,免费黄色视频在线看

public class Order{
    private Long id; //訂單Id
    private String orderNumber; //訂單編號(hào)
    private String deliveryAddress; //物流地址
    private List<Goods> goodsList;  //商品列表
    //省略了 getter/setter
}

public class Goods {
    private Long id; //商品Id
    private String goodsCode; //商品編號(hào)
    private String goodsName; //商品名稱
    private Double price; //商品價(jià)格
    //省略了 getter/setter
}

DROP TABLE IF EXISTS `order`;
DROP TABLE IF EXISTS `goods`;
DROP TABLE IF EXISTS `order_goods`;
create table `order` (
    `id` bigint(20) NOT NULL AUTO_INCREMENT,
    `order_number` varchar(50) not null,
    `delivery_address` varchar(100) not null,
  `create_time` timestamp not null DEFAULT CURRENT_TIMESTAMP,
    PRIMARY KEY (`id`)
);
create table `goods` (
  `id` bigint(20) NOT NULL AUTO_INCREMENT,
  `goods_code` varchar(50) not null,
  `goods_name` varchar(50) not null,
  `goods_price` double not null,
  `create_time` timestamp not null DEFAULT CURRENT_TIMESTAMP,
    PRIMARY KEY (`id`)
);
create table `order_goods` (
    `order_id` bigint(20) not null,
    `goods_id` bigint(20) not null,
    foreign key(`order_id`) references `order`(`id`),
    foreign key(`goods_id`) references `goods`(`id`)
);

public interface OrderRepository {
    Order addOrder(Order order);
    Order getOrderById(Long orderId);
    Order getOrderDetailByOrderNumber(String orderNumber);
}

@Repository("orderRawJdbcRepository")
public class OrderRawJdbcRepository implements OrderRepository {
    @Autowired
    private DataSource dataSource;
    @Override
    public Order getOrderById(Long orderId) {
        Connection connection = null;
        PreparedStatement statement = null;
        ResultSet resultSet = null;
        try {
            connection = dataSource.getConnection();
            statement = connection.prepareStatement("select id, order_number, delivery_address from `order` where id=?");
            statement.setLong(1, orderId);
            resultSet = statement.executeQuery();
            Order order = null;
            if (resultSet.next()) {
                order = new Order(resultSet.getLong("id"), resultSet.getString("order_number"),
                        resultSet.getString("delivery_address"));
            }
            return order;
        } catch (SQLException e) {
            System.out.print(e);
        } finally {
            if (resultSet != null) {
                try {
                    resultSet.close();
                } catch (SQLException e) {
                }
            }
            if (statement != null) {
                try {
                    statement.close();
                } catch (SQLException e) {
                }
            }
            if (connection != null) {
                try {
                    connection.close();
                } catch (SQLException e) {
                }
            }
        }
        return null;
    }
    //省略其他 OrderRepository 接口方法實(shí)現(xiàn)
}

spring:
  datasource:
    driver-class-name: com.mysql.cj.jdbc.Driver
    url: jdbc:mysql://127.0.0.1:3306/appointment
    username: root
    password: root

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-jdbc</artifactId>
</dependency>

@Repository("orderJdbcRepository")
public class OrderJdbcRepository implements OrderRepository {
    private JdbcTemplate jdbcTemplate;
    @Autowired
    public OrderJdbcRepository(JdbcTemplate jdbcTemplate) {
        this.jdbcTemplate = jdbcTemplate;
}
}

@Override
public Order getOrderById(Long orderId) {
        Order order = jdbcTemplate.queryForObject("select id, order_number, delivery_address from `order` where id=?",
                this::mapRowToOrder, orderId);
        return order;
}

public interface RowMapper<T> {
    T mapRow(ResultSet rs, int rowNum) throws SQLException;
}

private Order mapRowToOrder(ResultSet rs, int rowNum) throws SQLException {
        return new Order(rs.getLong("id"), rs.getString("order_number"), rs.getString("delivery_address"));
}

@Override
public Order getOrderDetailByOrderNumber(String orderNumber) {
        //獲取 Order 基礎(chǔ)信息
        Order order = jdbcTemplate.queryForObject(
                "select id, order_number, delivery_address from `order` where order_number=?", this::mapRowToOrder,
                orderNumber);
        if (order == null)
            return order;
        //獲取 Order 與 Goods 之間的關(guān)聯(lián)關(guān)系，找到給 Order 中的所有 GoodsId
        Long orderId = order.getId();
        List<Long> goodsIds = jdbcTemplate.query("select order_id, goods_id from order_goods where order_id=?",
                new ResultSetExtractor<List<Long>>() {
                    public List<Long> extractData(ResultSet rs) throws SQLException, DataAccessException {
                        List<Long> list = new ArrayList<Long>();
                        while (rs.next()) {
                            list.add(rs.getLong("goods_id"));
                        }
                        return list;
                    }
                }, orderId);
        //根據(jù) GoodsId 分別獲取 Goods 信息并填充到 Order 對(duì)象中
        for (Long goodsId : goodsIds) {
            Goods goods = getGoodsById(goodsId);
            order.addGoods(goods);
        }
        return order;
}

private Goods getGoodsById(Long goodsId) {
        return jdbcTemplate.queryForObject("select id, goods_code, goods_name, price from goods where id=?",
                this::mapRowToGoods, goodsId);
}
private Goods mapRowToGoods(ResultSet rs, int rowNum) throws SQLException {
        return new Goods(rs.getLong("id"), rs.getString("goods_code"), rs.getString("goods_name"),
                rs.getDouble("price"));
}

private Order addOrderDetailWithJdbcTemplate(Order order) {
        //插入 Order 基礎(chǔ)信息
        Long orderId = saveOrderWithJdbcTemplate(order);
        order.setId(orderId);
        //插入 Order 與 Goods 的對(duì)應(yīng)關(guān)系
        List<Goods> goodsList = order.getGoods();
        for (Goods goods : goodsList) {
            saveGoodsToOrderWithJdbcTemplate(goods, orderId);
        }
        return order;
}

private Long saveOrderWithJdbcTemplate(Order order) {
        PreparedStatementCreator psc = new PreparedStatementCreator() {
            @Override
            public PreparedStatement createPreparedStatement(Connection con) throws SQLException {
                PreparedStatement ps = con.prepareStatement(
                        "insert into `order` (order_number, delivery_address) values (?, ?)",
                        Statement.RETURN_GENERATED_KEYS);
                ps.setString(1, order.getOrderNumber());
                ps.setString(2, order.getDeliveryAddress());
                return ps;
            }
        };
        KeyHolder keyHolder = new GeneratedKeyHolder();
        jdbcTemplate.update(psc, keyHolder);
        return keyHolder.getKey().longValue();
}

private void saveGoodsToOrderWithJdbcTemplate(Goods goods, long orderId) {
        jdbcTemplate.update("insert into order_goods (order_id, goods_id) " + "values (?, ?)", orderId, goods.getId());
}

@Service
public class OrderService {
    @Autowired
    @Qualifier("orderJdbcRepository")
    private OrderRepository orderRepository;
    public Order addOrder(Order order) {
        return orderRepository.addOrder(order);
    } 
}
@RestController
@RequestMapping(value="orders")
public class OrderController {
    @RequestMapping(value = "", method = RequestMethod.POST)
    public Order addOrder(@RequestBody Order order) {
        Order result = orderService.addOrder(order);
     return result;
    }
}

{
    "orderNumber" : "Order10002",
    "deliveryAddress" : "test_address2",
    "goods": [
        {
            "id": 1,
            "goodsCode": "GoodsCode1",
            "goodsName": "GoodsName1",
            "price": 100.0
        }
    ]
}

private JdbcTemplate jdbcTemplate;
private SimpleJdbcInsert orderInserter;
private SimpleJdbcInsert orderGoodsInserter;
public OrderJdbcRepository(JdbcTemplate jdbcTemplate) {
        this.jdbcTemplate = jdbcTemplate;
        this.orderInserter = new SimpleJdbcInsert(jdbcTemplate).withTableName("`order`").usingGeneratedKeyColumns("id");
        this.orderGoodsInserter = new SimpleJdbcInsert(jdbcTemplate).withTableName("order_goods");
}

private Long saveOrderWithSimpleJdbcInsert(Order order) {
        Map<String, Object> values = new HashMap<String, Object>();
        values.put("order_number", order.getOrderNumber());
        values.put("delivery_address", order.getDeliveryAddress());
        Long orderId = orderInserter.executeAndReturnKey(values).longValue();
        return orderId;
}

private void saveGoodsToOrderWithSimpleJdbcInsert(Goods goods, long orderId) {
        Map<String, Object> values = new HashMap<>();
        values.put("order_id", orderId);
        values.put("goods_id", goods.getId());
        orderGoodsInserter.execute(values);
}

private Order addOrderDetailWithSimpleJdbcInsert(Order order) {
        //插入 Order 基礎(chǔ)信息
        Long orderId = saveOrderWithSimpleJdbcInsert(order);
        order.setId(orderId);
        //插入 Order 與 Goods 的對(duì)應(yīng)關(guān)系
        List<Goods> goodsList = order.getGoods();
        for (Goods goods : goodsList) {
            saveGoodsToOrderWithSimpleJdbcInsert(goods, orderId);
        }
        return order;
}