java—如何将数据插入h2数据库？

e37o9pze  于 2021-07-23  发布在  Java
关注(0)|答案(1)|浏览(463)

我有一个使用SpringBoot的代码库。
基于pom和属性文件，我得出结论，h2数据库正在使用中。
当应用程序第一次启动时，/orders api返回一些初始数据。问：我想知道这些数据是如何进入数据库的。没有对orderrepository的save方法的引用，这可能表示正在保存数据。
数据是指我在下面发布的特定数据。
我将数据源设置为本地路径，并注意到在命令mvn spring期间它的大小增加了-boot:run，用于启动应用程序。
数据是如何进入数据库的？我搜索了orderservice的save引用，但找不到任何内容。
pom.xml文件

<?xml version="1.0" encoding="UTF-8"?>
 <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
<modelVersion>4.0.0</modelVersion>
<parent>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-parent</artifactId>
    <version>2.1.4.RELEASE</version>
    <relativePath/> <!-- lookup parent from repository -->
</parent>
<groupId>com.akveo</groupId>
<artifactId>bundle-java</artifactId>
<version>1.0.0</version>
<name>bundle-java</name>
<description>Backend bundle in Java implementation for ngx admin</description>

<properties>
    <java.version>1.8</java.version>
    <maven.compiler.source>1.8</maven.compiler.source>
    <maven.compiler.target>1.8</maven.compiler.target>
</properties>

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

    <dependency>
        <groupId>commons-configuration</groupId>
        <artifactId>commons-configuration</artifactId>
        <version>1.6</version>
    </dependency>

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

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

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

    <dependency>
        <groupId>org.springframework.security</groupId>
        <artifactId>spring-security-test</artifactId>
        <scope>test</scope>
    </dependency>

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

    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-configuration-processor</artifactId>
        <optional>true</optional>
    </dependency>

    <dependency>
        <groupId>io.jsonwebtoken</groupId>
        <artifactId>jjwt</artifactId>
        <version>0.9.1</version>
    </dependency>

    <dependency>
        <groupId>org.modelmapper</groupId>
        <artifactId>modelmapper</artifactId>
        <version>2.3.3</version>
    </dependency>

    <dependency>
        <groupId>io.springfox</groupId>
        <artifactId>springfox-swagger2</artifactId>
        <version>2.9.2</version>
    </dependency>

    <dependency>
        <groupId>io.springfox</groupId>
        <artifactId>springfox-swagger-ui</artifactId>
        <version>2.9.2</version>
    </dependency>

    <dependency>
        <groupId>mysql</groupId>
        <artifactId>mysql-connector-java</artifactId>
        <version>8.0.19</version>
    </dependency>

    <dependency>
        <groupId>org.hibernate</groupId>
        <artifactId>hibernate-core</artifactId>
        <version>5.4.10.Final</version>
    </dependency>

    <dependency>
        <groupId>com.h2database</groupId>
        <artifactId>h2</artifactId>
        <scope>runtime</scope>
        <version>1.4.197</version>
    </dependency>

    <dependency>
        <groupId>com.google.code.findbugs</groupId>
        <artifactId>annotations</artifactId>
        <version>3.0.1</version>
        <scope>provided</scope>
    </dependency>

    <dependency>
        <groupId>com.fasterxml.jackson.core</groupId>
        <artifactId>jackson-databind</artifactId>
        <version>2.9.8</version>
    </dependency>

    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-test</artifactId>
    </dependency>
</dependencies>

<build>
    <plugins>
        <plugin>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-maven-plugin</artifactId>
        </plugin>

        <plugin>
            <groupId>org.codehaus.mojo</groupId>
            <artifactId>findbugs-maven-plugin</artifactId>
            <version>3.0.5</version>
            <configuration>
                <effort>Max</effort>
            </configuration>
            <executions>
                <execution>
                    <goals>
                        <goal>check</goal>
                    </goals>
                </execution>
            </executions>
        </plugin>
        <plugin>
            <groupId>org.apache.maven.plugins</groupId>
            <artifactId>maven-checkstyle-plugin</artifactId>
            <version>3.0.0</version>
            <configuration>
                <configLocation>checkstyle.xml</configLocation>
            </configuration>
            <executions>
                <execution>
                    <phase>validate</phase>
                    <goals>
                        <goal>check</goal>
                    </goals>
                </execution>
            </executions>
        </plugin>
    </plugins>
</build>

应用程序属性

spring.datasource.url=jdbc:h2:file:C:\\Users\\user\\Documents\\app-data
spring.datasource.driverClassName=org.h2.Driver
spring.datasource.username=sa
spring.datasource.password=password
spring.jpa.database-platform=org.hibernate.dialect.H2Dialect
spring.h2.console.enabled=true
spring.h2.console.path=/h2-console

# JWT

# 1 hour

jwt.accessTokenValidityInMilliseconds=3600000

# 30 days

jwt.refreshTokenValidityInMilliseconds=2592000000

# Client Info

client.url=http://localhost:3001/api
server.port=3001    
server.servlet.context-path=/api

# Client reset password expiration

client.resetPasswordToken.expiration=60m

# Clear expired tokens every day at midnight

client.resetPasswordToken.clearJob=0 0 0 * * ?

订单存储库

package com.akveo.bundlejava.ecommerce.repository;

import com.akveo.bundlejava.ecommerce.entity.Order;
import org.springframework.data.jpa.repository.JpaSpecificationExecutor;
import org.springframework.data.jpa.repository.Modifying;
import org.springframework.data.jpa.repository.Query;
import org.springframework.data.repository.PagingAndSortingRepository;

public interface OrderRepository extends PagingAndSortingRepository<Order, Long>, JpaSpecificationExecutor<Order> {
    @Modifying
    @Query("delete from Order t where t.id = ?1")
    void delete(Long entityId);
}

订单服务

package com.akveo.bundlejava.ecommerce.service;

import com.akveo.bundlejava.authentication.BundleUserDetailsService;
import com.akveo.bundlejava.authentication.exception.OrderNotFoundHttpException;
import com.akveo.bundlejava.ecommerce.DTO.OrderDTO;
import com.akveo.bundlejava.ecommerce.entity.GridData;
import com.akveo.bundlejava.ecommerce.entity.Country;
import com.akveo.bundlejava.ecommerce.entity.Order;
import com.akveo.bundlejava.ecommerce.entity.builder.PageableBuilder;
import com.akveo.bundlejava.ecommerce.entity.builder.OrderSpecificationBuilder;
import com.akveo.bundlejava.ecommerce.entity.filter.OrderGridFilter;
import com.akveo.bundlejava.ecommerce.repository.CountryRepository;
import com.akveo.bundlejava.ecommerce.repository.OrderRepository;
import com.akveo.bundlejava.user.User;
import com.akveo.bundlejava.user.UserRepository;
import org.modelmapper.ModelMapper;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.dao.EmptyResultDataAccessException;
import org.springframework.data.domain.Page;
import org.springframework.data.domain.Pageable;
import org.springframework.data.jpa.domain.Specification;
import org.springframework.http.HttpStatus;
import org.springframework.security.core.Authentication;
import org.springframework.stereotype.Service;

import javax.transaction.Transactional;
import java.util.List;
import java.util.Optional;
import java.util.stream.Collectors;

@Service
public class OrderService {
    private OrderRepository orderRepository;
    private CountryRepository countryRepository;
    private ModelMapper modelMapper;
    private PageableBuilder pageableBuilder;
    private UserRepository userRepository;

    @Autowired
    OrderService(OrderRepository orderRepository,
                 UserRepository userRepository,
                 CountryRepository countryRepository,
                 PageableBuilder pageableBuilder,
                 ModelMapper modelMapper) {
        this.modelMapper = modelMapper;
        this.countryRepository = countryRepository;
        this.userRepository = userRepository;
        this.orderRepository = orderRepository;
        this.pageableBuilder = pageableBuilder;
    }

    @Transactional
    public boolean delete(Long id) {
        try {
            orderRepository.delete(id);
            return true;
        } catch (EmptyResultDataAccessException e) {
            throw new OrderNotFoundHttpException("Order with id: " + id + " not found", HttpStatus.NOT_FOUND);
        }
    }

    public OrderDTO getOrderById(Long id) {
        Order existingOrder = orderRepository.findById(id).orElseThrow(
                () -> new OrderNotFoundHttpException("User with id: " + id + " not found", HttpStatus.NOT_FOUND)
        );

        return modelMapper.map(existingOrder, OrderDTO.class);
    }

    private List<OrderDTO> mapOrdersToOrderDTO(List<Order> orders) {
        return orders.stream().map(order ->
                modelMapper.map(order, OrderDTO.class)
        ).collect(Collectors.toList());
    }

    private GridData<OrderDTO> parsePageToGridData(Page<Order> orderPages) {
        GridData<OrderDTO> gridData = new GridData<>();
        List<Order> orderList = orderPages.getContent();
        long totalCount = orderPages.getTotalElements();
        gridData.setItems(mapOrdersToOrderDTO(orderList));
        gridData.setTotalCount(totalCount);
        return gridData;
    }

    public GridData<OrderDTO> getDataForGrid(OrderGridFilter filter) {
        OrderSpecificationBuilder specificationBuilder = new OrderSpecificationBuilder();

        Pageable paginationAndSort = pageableBuilder.build(filter);
        Optional<Specification<Order>> optionalSpec = specificationBuilder.build(filter);
        Page<Order> orderPages = optionalSpec
                .map(orderSpecification -> orderRepository.findAll(orderSpecification, paginationAndSort))
                .orElseGet(() -> orderRepository.findAll(paginationAndSort));
        return parsePageToGridData(orderPages);
    }

    @Transactional
    public OrderDTO updateOrderById(Long id, OrderDTO orderDTO, Authentication auth) {
        return update(id, orderDTO, auth);
    }

    private OrderDTO update(Long id, OrderDTO orderDTO, Authentication auth) {
        Order orderFromDB = orderRepository.findById(id).orElseThrow(
                () -> new OrderNotFoundHttpException("Order with id: " + id + " not found", HttpStatus.NOT_FOUND)
        );

        User createdUser = orderFromDB.getCreatedByUserId();

        Long userId = ((BundleUserDetailsService.BundleUserDetails) auth.getPrincipal()).getUser().getId();
        Optional<User> optionalUser = userRepository.findById(userId);
        User updatedUser = optionalUser.orElse(null);

        Order order = modelMapper.map(orderDTO, Order.class);

        Long countryId = orderFromDB.getCountry().getId();

        if (countryId == 0) {
            Country country = countryRepository.getOne(countryId);
            orderFromDB.setCountry(country);
        }

        order.setUpdatedByUserId(updatedUser);
        order.setCreatedByUserId(createdUser);
        orderRepository.save(order);

        return orderDTO;
    }

    @Transactional
    public OrderDTO createOrder(Authentication auth, OrderDTO orderDTO) {
        Long userId = ((BundleUserDetailsService.BundleUserDetails) auth.getPrincipal()).getUser().getId();

        Optional<User> optionalUser = userRepository.findById(userId);
        User user = optionalUser.orElse(null);

        Order order = modelMapper.map(orderDTO, Order.class);

        order.setCreatedByUserId(user);
        order.setUpdatedByUserId(user);
        orderRepository.save(order);

        return orderDTO;
    }
}

订单控制器

package com.akveo.bundlejava.ecommerce.controller;

import com.akveo.bundlejava.authentication.ResponseMessage;
import com.akveo.bundlejava.ecommerce.DTO.OrderDTO;
import com.akveo.bundlejava.ecommerce.entity.GridData;
import com.akveo.bundlejava.ecommerce.entity.filter.OrderGridFilter;
import com.akveo.bundlejava.ecommerce.service.OrderService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
import org.springframework.security.core.Authentication;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.DeleteMapping;
import org.springframework.web.bind.annotation.PutMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;

import javax.validation.Valid;

import static org.springframework.http.ResponseEntity.ok;

@Controller
@RequestMapping("/orders")
public class OrdersController {
    private OrderService orderService;

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

    @GetMapping("")
    public ResponseEntity<GridData<OrderDTO>> getDataForGrid(OrderGridFilter orderGridFilter) {
        return ok(orderService.getDataForGrid(orderGridFilter));
    }

    @GetMapping("/{id}")
    public ResponseEntity<OrderDTO> get(@PathVariable Long id) {
        return ok(orderService.getOrderById(id));
    }

    @PostMapping("")
    public ResponseEntity<OrderDTO> create(Authentication auth, @Valid @RequestBody OrderDTO orderDTO) {
        return ok(orderService.createOrder(auth, orderDTO));
    }

    @PutMapping("/{id}")
    public ResponseEntity edit(Authentication auth, @PathVariable Long id, @Valid @RequestBody OrderDTO orderDTO) {
        if (!id.equals(orderDTO.getId())) {
            return new ResponseEntity<>(
                    "Id must be equal",
                    HttpStatus.BAD_REQUEST);
        }
        return ok(orderService.updateOrderById(id, orderDTO, auth));
    }

    @DeleteMapping("/{id}")
    public ResponseEntity<ResponseMessage> delete(@PathVariable Long id) {
        orderService.delete(id);
        return ok(new ResponseMessage("Ok"));
    }
}

来自orders终结点的数据（在应用程序启动时第一次调用之后）：

{
   "totalCount": 6089,
   "items": [
      {
         "id": 6089,
         "name": "Order 13988",
         "date": "2020-11-06T16:49:04.612",
         "sum": {
            "value": 959.55,
            "currency": "USD"
         },
         "type": "Tables",
         "status": "Payment",
         "country": {
            "id": 22,
            "name": "Suriname"
         }
      },
      {
         "id": 6088,
         "name": "Order 16403",
         "date": "2020-09-02T16:49:04.612",
         "sum": {
            "value": 721.46,
            "currency": "USD"
         },
         "type": "Furniture",
         "status": "Payment",
         "country": {
            "id": 139,
            "name": "Greenland"
         }
      },
      {
         "id": 6087,
         "name": "Order 12129",
         "date": "2020-11-15T16:49:04.612",
         "sum": {
            "value": 814.51,
            "currency": "USD"
         },
         "type": "Textiles",
         "status": "Payment",
         "country": {
            "id": 100,
            "name": "Madagascar"
         }
      },
      {
         "id": 6086,
         "name": "Order 910",
         "date": "2020-12-27T16:49:04.612",
         "sum": {
            "value": 585.34,
            "currency": "USD"
         },
         "type": "Textiles",
         "status": "Payment",
         "country": {
            "id": 148,
            "name": "Japan"
         }
      },
      {
         "id": 6085,
         "name": "Order 127",
         "date": "2020-09-16T16:49:04.612",
         "sum": {
            "value": 894.64,
            "currency": "USD"
         },
         "type": "Tables",
         "status": "Payment",
         "country": {
            "id": 30,
            "name": "Bhutan"
         }
      },
      {
         "id": 6084,
         "name": "Order 14774",
         "date": "2020-11-07T16:49:04.612",
         "sum": {
            "value": 865.38,
            "currency": "USD"
         },
         "type": "Tables",
         "status": "Cancelled",
         "country": {
            "id": 100,
            "name": "Madagascar"
         }
      },
      {
         "id": 6083,
         "name": "Order 12590",
         "date": "2021-01-04T16:49:04.612",
         "sum": {
            "value": 708.94,
            "currency": "USD"
         },
         "type": "Textiles",
         "status": "Cancelled",
         "country": {
            "id": 75,
            "name": "Albania"
         }
      },
      {
         "id": 6082,
         "name": "Order 14544",
         "date": "2020-09-26T16:49:04.612",
         "sum": {
            "value": 401.37,
            "currency": "USD"
         },
         "type": "Textiles",
         "status": "Payment",
         "country": {
            "id": 157,
            "name": "Hungary"
         }
      },
      {
         "id": 6081,
         "name": "Order 7908",
         "date": "2020-11-17T16:49:04.612",
         "sum": {
            "value": 222.02,
            "currency": "USD"
         },
         "type": "Lightning",
         "status": "Cancelled",
         "country": {
            "id": 42,
            "name": "Iraq"
         }
      },
      {
         "id": 6080,
         "name": "Order 14165",
         "date": "2020-08-31T16:49:04.612",
         "sum": {
            "value": 879.75,
            "currency": "USD"
         },
         "type": "Furniture",
         "status": "Cancelled",
         "country": {
            "id": 140,
            "name": "Yemen"
         }
      }
   ]
}
Javaspringspring-booth2orm

1条答案

按热度按时间
kx1ctssn

kx1ctssn1#

我做了一些关于spring初始化工作原理的研究，发现了一个由以下注解的方法：

@EventListener(ContextStartedEvent.class)

如本文所述。

赞(0）分享  回复(0）举报  2021-07-23
我来回答

相关问题

    查看更多

    热门标签

    更多
    JavaquerypythonNode开发语言requestUtil数据库Table后端算法LoggerMessageElementParser

    最新问答

    更多
    • 蜀ICP备2022004421号-2 NULL123 https://www.null123.com © All rights reserved
    • 本站内容来源互联网,如果侵犯您的权益请联系我们删除, 联系方式：448109455@qq.com