如何修复此错误：无法写入 JSON：未能延迟初始化角色集合：com.cashregister.demo.model

Question

I'm getting stuck when trying to create a Transaction object and then return a list of transactions. The error I'm getting when calling http://localhost:8080/transactions is:

{
  "timestamp": "2020-08-13T14:24:11.113+0000",
  "status": 500,
  "error": "Internal Server Error",
  "message": "Could not write JSON: failed to lazily initialize a collection of role: com.cashregister.demo.model.Transaction.items, could not initialize proxy - no Session; nested exception is com.fasterxml.jackson.databind.JsonMappingException: failed to lazily initialize a collection of role: com.cashregister.demo.model.Transaction.items, could not initialize proxy - no Session (through reference chain: java.util.HashMap[\"transactions\"]->java.util.ArrayList[0]->com.cashregister.demo.model.Transaction[\"items\"])",
  "path": "/transactions"
}

I've been searching for solutions, but none seem to get rid of the error and return. Can someone please help resolve this issue so that the response when getting all transactions is returned in the format:

{
  "transaction": {
    "id": 1,
    "total": 46.44,
    "customer": {
      "id": 1,
      "phoneNumber": "9416970394",
      "lastName": "Weber",
      "loyaltyNumber": "2484801419"
    },
    "items": [
     // list of each item in the transaction
    ]

Here is my code:

Item.java Model

@Entity
public class Item {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;

    @ManyToOne(fetch = FetchType.LAZY)
    @JoinColumn(name = "transaction_id", nullable = false)
    private Transaction transaction;

    @NotNull
    private double total;

    @NotNull
    @OneToOne
    private Product product;

    @NotNull
    private int quantity;

// Getters and setters
}

Transaction.java Model

@Entity
public class Transaction {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;

    private double total;

    @ManyToOne
    private Customer customer;

    @OneToMany(mappedBy = "transaction", fetch = FetchType.LAZY, cascade = CascadeType.ALL)
    private List<Item> items = new ArrayList<>();

// Getters and setters
}

TransactionDaoImpl.java for DB Access

@Repository
public class TransactionDaoImpl implements TransactionDao {
    @Autowired
    private SessionFactory sessionFactory;

    @Override
    public List<Transaction> findAll() {
        Session session = sessionFactory.openSession();
        List<Transaction> transactions = session.createCriteria(Transaction.class).list();
        session.close();
        return transactions;
    }

    @Override
    public Transaction findById(Long id) {
        Session session = sessionFactory.openSession();
        Transaction transaction = session.get(Transaction.class, id);
        session.close();
        return transaction;
    }

    @Override
    public Long save(Transaction transaction) {
        Session session = sessionFactory.openSession();
        session.beginTransaction();
        session.saveOrUpdate(transaction);
        session.getTransaction().commit();
        session.close();
        return transaction.getId();
    }
}

TransctionController.java

@RestController
@RequestMapping("/transactions")
public class TransactionController {
    @Autowired
    private TransactionService transactionService;

    @Autowired
    private CustomerService customerService;

    @Autowired
    private ProductService productService;

    @Autowired
    private ItemService itemService;

    @RequestMapping(value = "")
    public Map<String, List<Transaction>> listTransactions() {
        Map<String, List<Transaction>> response = new HashMap<>();
        List<Transaction> transactions = transactionService.findAll();
        response.put("transactions", transactions);
        return response;
    }

    @RequestMapping(value = "{transaction_id}")
    public Map<String, Transaction> findTransactionById(@PathVariable Long transaction_id) {
        Map<String, Transaction> response = new HashMap<>();
        Transaction transaction = transactionService.findById(transaction_id);
        response.put("transaction", transaction);
        return response;
    }

    @RequestMapping(value = "", method = RequestMethod.POST)
    public Map<String, Transaction> createTransaction(@RequestBody List<Product> products, @RequestParam("user_id") Long customerId) {
        Map<String, Transaction> response = new HashMap<>();

        Customer customer = customerService.findById(customerId);

        // Get unique skus to get the product objects from the database (source of truth).
        Set<String> skus = new HashSet<>();
        for (final Product product : products) {
            skus.add(product.getSku());
        }
        List<String> skusStrings = new ArrayList<String>();
        for(String sku : skus) {
            skusStrings.add(sku);
        }
        List<Product> productsFromDb = productService.findBySkus(skusStrings);

        // Loop through products in payload to calculate quantity.
        List<Item> items = new ArrayList<>();
        Map<String, Integer> productQuantity = new HashMap<>();
        for(Product product : products) {
            if(productQuantity.containsKey(product.getSku())) {
                productQuantity.put(product.getSku(), productQuantity.get(product.getSku()) + 1);
            } else {
                productQuantity.put(product.getSku(), 1);
            }
        }

        // Calculate total cost
        double total = 0;
        for(Product product : productsFromDb) {
            if(!customer.getLoyaltyNumber().isEmpty()) {
                total += product.getDiscountPrice() * productQuantity.get(product.getSku());
            } else {
                total += product.getDefaultPrice() * productQuantity.get(product.getSku());
            }
        }

        // Calculate item total and append to Items list
        Map<String, Double> productTotal = new HashMap<>();
        for(Product product : productsFromDb) {
            if(!customer.getLoyaltyNumber().isEmpty()) {
                productTotal.put(product.getSku(), productQuantity.get(product.getSku()) * product.getDiscountPrice());
            } else {
                productTotal.put(product.getSku(), productQuantity.get(product.getSku()) * product.getDefaultPrice());
            }
        }

        Transaction t = new Transaction();
        t.setTotal(total);
        t.setCustomer(customer);
        t.setItems(items);

        Long transactionId = transactionService.save(t);

        for(Product product : productsFromDb) {
            Item item = new Item(t, productTotal.get(product.getSku()), product, productQuantity.get(product.getSku()));
            itemService.save(item);
        }

        Transaction transaction = transactionService.findById(transactionId);

        response.put("transaction", transaction);
        return response;
    }
}

Answer 1

Your Transaction entity has relation to Item entity. So in your controller you don't have any database session for fetching Items. You must put all your code in Service layer and then put @Transactional on it. Short and bad response is set the spring.jpa.open-in-view property to true.

Answer 2

The issue here is Lazy Loading by Hibernate . This is actually JPA spec and implemented by Hibernate. the main concept is not to load up all association, giving a performance boost.

Why you facing this issue:

• You have defined the FETCH strategy as LAZY on both sides (Here, Relationship from Transaction to Item matters since you fetching Transaction)
• TransactionDaoImpl#findAll() method opens a Session and fetched the records. Hibernate, according to the Lazy Load concept, does not fetch the associated Items from the DB, instead, creates Proxies.
• Since these are Proxy Objects, the HttpMessageConverter cannot convert those objects to JSON representation.

How to resolve the issue:

1. You have to call a get accessor on the item relationship.

   @Transactional // This is required since you are not using Spring data Jpa Repository abstractions. Or else you can explicitly define the transaction boundary inside the method by opening the transaction and closing it.
   @Override
    public List<Transaction> findAll() {
        Session session = sessionFactory.openSession();
        List<Transaction> transactions = session.createCriteria(Transaction.class).list();
        transactions.foreach(Transaction::getItems);
        session.close();
        return transactions;
    }

But this will give rise to a N+1 issue .

Mainly. for each transaction, N number of queries will be fired for each transaction (N is the number of Items for one transaction) - so K*N number of queries will be fired.

2. To resolve the N+1 issue, you can go with a Native query using Join to fetch all the data with one single query. Since a JOIN, still performance will be slow, but much better than 1st option. Or you can with Hibernate Annotation or JPQL/HQL JOIN FETCH , which essentially creates the JOIN for you.

3. Another Option to load the data without N+1 query is @EntityGraphy . I have not used it. But you can read more about it here