There are several important Spring Projects solving the needs of enterprises today. But first, it is essential to understand what are Spring Projects and how are they different from Spring Modules?
Within the Spring Framework, there are a variety of different Spring modules — JDBC, AOP, Beans, and Context. All Spring Modules share the same release version as the Spring Framework. They are part of the same project.
Apart from the Spring Framework and its various modules, there are other frameworks called Spring Projects. These projects provide solutions to other issues faced by enterprise applications.
These projects are versioned differently from the Spring Framework. For example, the current version of the Spring Framework is 5.x.x and that of Spring Boot (one of the Spring Projects) is 2.x.x.
Spring Boot is one of the most popular frameworks for developing microservices today. Spring Boot makes it easy to develop applications quickly. It has important features such as starter projects, auto-configuration, and actuator; it is a cakewalk to develop microservices.
The world is moving more and more towards the cloud. Everyone wants to deploy their application in the cloud. If you develop a microservice using Spring Boot, you could use Spring Cloud to make it cloud-enabled.
Spring Data provides mechanisms for consistent data access.
A few years earlier, there was only one kind of database that an application could connect to — the SQL-based relational databases. Today, we also have at our disposal a wide variety of databases including the NoSQL databases.
Spring Data ensures that the way we access data from all these sources remains consistent.
Spring Integration, on the other hand, addresses the issues of application integration.
Spring Integration provides implementations for recommended architecture patterns in Enterprise Application Integration.
Not all processing is done online, and a lot is also accomplished through batch applications.
Batch applications have their own unique set of requirements. For instance, it is important to be able to restart a batch job from the point where it had failed earlier. It may also be necessary to track down accurately what is happening in the background when a batch job executes.
Spring Batch provides a great option to develop batch applications.
Security is one of the most important non-functional requirements of an application’s development. Any application that you develop, be it a web application, a REST service, or any other, you want it to be secure.
Spring Security provides features for securing the applications that you develop. It has support for basic authentication, OAuth1, and OAuth2 authentication.
With RESTful services, it is not sufficient if you simply return the data for a resource. It is also recommended to return related actions you can perform on the resource. This is called HATEOAS. Spring HATEOAS enables you to develop HATEOAS compatible REST API.
Do check out our video on the same topic:
We have looked at seven of the available Spring projects. This is an evolving space and there are new Spring projects every year to solve emerging enterprise problems.
In this tutorial, we’ll have a look at how deleting is done in Spring Data JPA.
As we know from the Spring Data JPA reference documentation, repository interfaces provide us some basic support for entities.
If we have an entity, like a Book:
@Entity public class Book { @Id @GeneratedValue private Long id; private String title; // standard constructors // standard getters and setters }
Then, we can extend Spring Data JPA’s CrudRepository to give us access to CRUD operations on Book:
@Repository public interface BookRepository extends CrudRepository<Book, Long> {}
Among others, CrudRepository contains two methods: deleteById and deleteAll.
Let’s test these methods directly from our BookRepository:
@RunWith(SpringRunner.class) @SpringBootTest(classes = {Application.class}) public class DeleteFromRepositoryUnitTest { @Autowired private BookRepository repository; Book book1; Book book2; List<Book> books; // data initialization @Test public void whenDeleteByIdFromRepository_thenDeletingShouldBeSuccessful() { repository.deleteById(book1.getId()); assertThat(repository.count()).isEqualTo(1); } @Test public void whenDeleteAllFromRepository_thenRepositoryShouldBeEmpty() { repository.deleteAll(); assertThat(repository.count()).isEqualTo(0); } }
And even though we are using CrudRepository, note that these same methods exist for other Spring Data JPA interfaces like JpaRepository or PagingAndSortingRepository.
We can also derive query methods for deleting entities. There is a set of rules for writing them, but let’s just focus on the simplest example.
A derived delete query must start with deleteBy, followed by the name of the selection criteria.These criteria must be provided in the method call.
Let’s say that we want to delete Books by title. Using the naming convention, we’d start with deleteBy and list title as our criteria:
@Repository public interface BookRepository extends CrudRepository<Book, Long> { long deleteByTitle(String title); }
The return value, of type long, indicates how many records the method deleted.
Let’s write a test and make sure that is correct:
@Test @Transactional public void whenDeleteFromDerivedQuery_thenDeletingShouldBeSuccessful() { long deletedRecords = repository.deleteByTitle("The Hobbit"); assertThat(deletedRecords).isEqualTo(1); }
Persisting and deleting objects in JPA requires a transaction, that’s why we should use a@Transactional annotation when using these derived delete queries, to make sure a transaction is running. This is explained in detail in the ORM with Spring documentation.
The method names for derived queries can get quite long, and they are limited to just a single table.
When we need something more complex, we can write a custom query using @Query and @Modifying together.
Let’s check the equivalent code for our derived method from earlier:
@Modifying @Query("delete from Book b where b.title=:title") void deleteBooks(@Param("title") String title);
Again, we can verify it works with a simple test:
@Test @Transactional public void whenDeleteFromCustomQuery_thenDeletingShouldBeSuccessful() { repository.deleteBooks("The Hobbit"); assertThat(repository.count()).isEqualTo(1); }
Both solutions presented above are similar and achieve the same result. However, they take a slightly different approach.
The @Query method creates a single JPQL query against the database. By comparison, thedeleteBy methods execute a read query, then delete each of the items one by one.
Let’s see now what happens when we have relationships with other entities.
Assume we have a Category entity, that has a OneToMany association with the Book entity:
@Entity public class Category { @Id @GeneratedValue private Long id; private String name; @OneToMany(mappedBy = "category", cascade = CascadeType.ALL, orphanRemoval = true) private List<Book> books; // standard constructors // standard getters and setters }
The CategoryRepository can just be an empty interface that extends CrudRepository:
@Repository public interface CategoryRepository extends CrudRepository<Category, Long> {}
We should also modify the Book entity to reflect this association:
@ManyToOne private Category category;
Let’s now add two categories and associate them with the books we currently have. Now, if we try to delete the categories, the books will also be deleted:
@Test public void whenDeletingCategories_thenBooksShouldAlsoBeDeleted() { categoryRepository.deleteAll(); assertThat(bookRepository.count()).isEqualTo(0); assertThat(categoryRepository.count()).isEqualTo(0); }
This is not bi-directional, though. That means that if we delete the books, the categories are still there:
@Test public void whenDeletingBooks_thenCategoriesShouldAlsoBeDeleted() { bookRepository.deleteAll(); assertThat(bookRepository.count()).isEqualTo(0); assertThat(categoryRepository.count()).isEqualTo(2); }
We can change this behavior by changing the properties of the relationship, such as the CascadeType.
In this article, we looked at different ways to delete entities in Spring Data JPA. Thank for reading !
Originally published on https://www.baeldung.com
#spring-boot #web-development