[JAVA] Si vous supprimez une collection immuable avec JPA, vous obtiendrez naturellement une UnsupportedOperationException.

Normalement, vous voyez rarement UnsupportedOperationException. Si vous faites par inadvertance un add ou `` remove``` sur une collection immuable, c'est probablement le cas.

Cependant, j'ai rencontré UnsupportedOperationException dans JPA et j'y ai été accro pendant un moment, donc je vais laisser une note.

Ce que je veux faire est de conserver l'entité 1: N, puis de supprimer la collection enfant pour cette entité.

	@Transactional
	@Override
	public void run(String... args) throws Exception {
		Parent parent = new Parent(5L, "name", List.of(
				new Child(new ChildId(101L, 1L), "aaa", null),
				new Child(new ChildId(102L, 1L), "bbb", null)
				));
		em.persist(parent);
		
		Parent parent2 = pr.getOne(5L);
		System.out.println(parent == parent2); // true
		List<Child> children = parent2.getChildren();
		parent2.getChildren().clear();
		em.persist(parent2);
	}

Caused by: java.lang.UnsupportedOperationException: null
	at java.base/java.util.ImmutableCollections.uoe(ImmutableCollections.java:71) ~[na:na]
	at java.base/java.util.ImmutableCollections$AbstractImmutableCollection.clear(ImmutableCollections.java:77) ~[na:na]
	at org.hibernate.collection.internal.PersistentBag.clear(PersistentBag.java:495) ~[hibernate-core-5.4.20.Final.jar:5.4.20.Final]

Avec le code ci-dessus, la même instance est renvoyée pour parent et `` `` parent2. Ensuite, `getChildren``` renverra une collection immuable de List.of```, donc`` clear donnera lieu à` ``UnsupportedOperationException.

Je n'ai pas immédiatement remarqué que la même instance avait été renvoyée car le code réel était séparé l'un de l'autre dans le contexte de persistance. Je pensais sans le savoir que si je le mettais dans un contexte de persistance et que je le récupérais, il serait reconditionné dans une collection mutable telle que ArrayList, donc le code ci-dessus renverrait la même instance. J'en étais accro sans m'en apercevoir.