{"id":3415,"date":"2024-09-19T16:15:31","date_gmt":"2024-09-19T14:15:31","guid":{"rendered":"https:\/\/nguenkam.com\/blog\/?p=3415"},"modified":"2024-09-20T15:09:45","modified_gmt":"2024-09-20T13:09:45","slug":"introduction-to-java-spring-boot-part-iii","status":"publish","type":"post","link":"https:\/\/nguenkam.com\/blog\/index.php\/2024\/09\/19\/introduction-to-java-spring-boot-part-iii\/","title":{"rendered":"Introduction to Java Spring Boot (Part III)"},"content":{"rendered":"\n

1. Structure of a Spring Boot Project<\/h4>\n\n\n\n

The typical structure of a Spring Boot project looks like this:<\/p>\n\n\n\n

\"\"<\/figure>\n\n\n\n
Explanations of the Structure:<\/h5>\n\n\n\n
  • src\/main\/java<\/strong>: This is where all the Java code resides.<\/li>
  • com\/example<\/strong>: The base package name, usually reflecting the company’s domain name.<\/li>
  • controller\/<\/strong>: Contains the REST controllers that handle HTTP requests.<\/li>
  • service\/<\/strong>: Business logic is implemented here.<\/li>
  • repository\/<\/strong>: Data access objects that interact with the database.<\/li>
  • Application.java<\/strong>: The main application class that contains the main<\/code> method and starts Spring Boot.<\/li>
  • src\/main\/resources<\/strong>: This is where resources like configuration files and static files are located.<\/li>
  • application.properties<\/strong>: Configuration file for Spring Boot.<\/li>
  • static\/<\/strong>: Static resources like CSS, JS, and images.<\/li>
  • templates\/<\/strong>: Templates for rendering views (e.g., Thymeleaf).<\/li>
  • src\/test\/java<\/strong>: This is where the tests for the application are located.<\/li>
  • pom.xml<\/strong>: Maven project file that defines dependencies and plugins.<\/li><\/ul>\n\n\n\n

    2. AOP Concepts (Aspect-Oriented Programming)<\/h4>\n\n\n\n

    AOP allows you to separate cross-cutting concerns like logging, transactions, and security from business logic. Important terms include:<\/p>\n\n\n\n

    • Aspect<\/strong>: A modular unit of cross-cutting logic.<\/li>
    • Join Point<\/strong>: A specific point in the program flow where an aspect can be applied.<\/li>
    • Advice<\/strong>: The code that is executed at a Join Point.<\/li>
    • Pointcut<\/strong>: An expression that defines the Join Points where Advice is applied.<\/li><\/ul>\n\n\n\n
      Example:<\/h5>\n\n\n\n
      import org.aspectj.lang.annotation.Aspect;\nimport org.aspectj.lang.annotation.Before;\nimport org.springframework.stereotype.Component;\n\n@Aspect\n@Component\npublic class LoggingAspect {\n\n    @Before(\"execution(* com.example.service.*.*(..))\")\n    public void logBeforeMethod() {\n        System.out.println(\"A method is being called.\");\n    }\n}<\/code><\/pre>\n\n\n\n
      3. Database Access in Spring Boot<\/h4>\n\n\n\n
      JDBC Template Example<\/h5>\n\n\n\n
      import org.springframework.beans.factory.annotation.Autowired;\nimport org.springframework.jdbc.core.JdbcTemplate;\nimport org.springframework.stereotype.Repository;\n\nimport java.util.List;\nimport java.util.Map;\n\n@Repository\npublic class UserRepository {\n\n    @Autowired\n    private JdbcTemplate jdbcTemplate;\n\n    public Map<String, Object> getUserById(int id) {\n        String sql = \"SELECT * FROM users WHERE id = ?\";\n        return jdbcTemplate.queryForMap(sql, id);\n    }\n\n    public List<Map<String, Object>> getAllUsers() {\n        String sql = \"SELECT * FROM users\";\n        return jdbcTemplate.queryForList(sql);\n    }\n}<\/code><\/pre>\n\n\n\n
      Difference between queryForMap<\/code> and queryForList<\/code><\/h5>\n\n\n\n
      • queryForMap<\/code><\/strong>: Returns a single row as a Map<\/code>, using column names as keys.<\/li>
      • queryForList<\/code><\/strong>: Returns a list of rows, with each row represented as a Map<\/code>.<\/li><\/ul>\n\n\n\n
        JdbcTemplate<\/code> supports batch processing, which allows us to execute multiple SQL statements in a single batch. This can significantly improve performance when inserting or updating large amounts of<\/p>\n\n\n\n
        public void batchAddUsers(List<User> users) {\n    String sql = \"INSERT INTO users (name, email) VALUES (?, ?)\";\n    jdbcTemplate.batchUpdate(sql, new BatchPreparedStatementSetter() {\n        @Override\n        public void setValues(PreparedStatement ps, int i) throws SQLException {\n            ps.setString(1, users.get(i).getName());\n            ps.setString(2, users.get(i).getEmail());\n        }\n\n        @Override\n        public int getBatchSize() {\n            return users.size();\n        }\n    });\n}\n<\/code><\/pre>\n\n\n\n
        To convert rows of the result set into custom objects, we can implement the RowMapper<\/code> interface. This is especially useful for queries that return multiple rows.<\/p>\n\n\n\n
        public List<User> getAllUsers() {\n    String sql = \"SELECT * FROM users\";\n    return jdbcTemplate.query(sql, new UserRowMapper());\n}\n<\/code><\/pre>\n\n\n\n
        When performing multiple operations that need to be executed as a single unit of work, we can manage transactions using Spring’s @Transactional<\/code> annotation.<\/p>\n\n\n\n
        @Transactional\npublic void createUserAndProfile(User user, Profile profile) {\n    addUser(user.getName(), user.getEmail());\n    \/\/ Insert profile logic here\n}\n<\/code><\/pre>\n\n\n\n
        4. Spring Data JDBC<\/h4>\n\n\n\n
        Spring Data JDBC is a part of the Spring Data project that provides a simplified way to access relational databases using plain JDBC. It focuses on a more straightforward approach to data access by leveraging the concepts of repositories and entities, while maintaining a close relationship with the underlying database.<\/p>\n\n\n\n
        Key Features of Spring Data JDBC:<\/h5>\n\n\n\n
        1. Entity Mapping<\/strong>: Maps Java objects directly to database tables without the complexity of ORM (Object-Relational Mapping).<\/li>
        2. Repository Support<\/strong>: Provides a repository abstraction, allowing you to perform CRUD operations without writing boilerplate code.<\/li>
        3. Simplicity<\/strong>: Offers a simpler programming model compared to JPA, making it easier to understand and use for straightforward use cases.<\/li><\/ol>\n\n\n\n
          Here’s a simple example of using Spring Data JDBC:<\/p>\n\n\n\n
          import org.springframework.data.annotation.Id;\nimport org.springframework.data.jdbc.core.mapping.Table;\nimport org.springframework.data.repository.CrudRepository;\nimport org.springframework.stereotype.Repository;\n\nimport java.util.List;\n\n@Table(\"users\")\npublic class User {\n    @Id\n    private Long id;\n    private String name;\n    private String email;\n\n    \/\/ Getters and Setters\n}\n\n@Repository\npublic interface UserRepository extends CrudRepository<User, Long> {\n    List<User> findByName(String name);\n}\n<\/code><\/pre>\n\n\n\n
          In this example:<\/p>\n\n\n\n
          • The User<\/code> class represents a table in the database, with fields mapped to columns.<\/li>
          • The UserRepository<\/code> interface extends CrudRepository<\/code>, providing methods to perform CRUD operations without additional implementation.<\/li><\/ul>\n\n\n\n
            5. Spring Data JPA<\/h4>\n\n\n\n
            What is JPA?<\/h5>\n\n\n\n
            Java Persistence API (JPA) is a specification for managing relational data in Java applications. Spring Data JPA simplifies the implementation of JPA-based repositories.<\/p>\n\n\n\n
            Concrete Example<\/h5>\n\n\n\n
            import org.springframework.data.jpa.repository.JpaRepository;\nimport org.springframework.stereotype.Repository;\n\n@Repository\npublic interface UserRepository extends JpaRepository<User, Integer> {\n    List<User> findByLastName(String lastName);\n}<\/code><\/pre>\n\n\n\n
            Dynamic Finder Methods (supported keywords)<\/h5>\n\n\n\n
            • findBy<\/code>: Searches by a specific attribute.<\/li>
            • findByFirstNameAndLastName<\/code>: Searches by multiple attributes.<\/li>
            • findByAgeGreaterThan<\/code>: Searches for values greater than a specific value.<\/li><\/ul>\n\n\n\n
              Advantages of JPA<\/h5>\n\n\n\n
              • Simplicity<\/strong>: Less boilerplate code compared to JDBC.<\/li>
              • Abstraction<\/strong>: Hides the complexity of database interaction.<\/li>
              • Flexibility<\/strong>: Supports different databases without changes to the code.<\/li><\/ul>\n\n\n\n
                5. Comparison: JDBC, JdbcTemplate, and JPA<\/h4>\n\n\n\n
                Feature<\/th>JDBC<\/th>JdbcTemplate<\/th>JPA<\/th><\/tr><\/thead>
                Level of Abstraction<\/strong><\/td>Low (direct database interaction)<\/td>Medium (simplifies JDBC operations)<\/td>High (object-oriented data access)<\/td><\/tr>
                Ease of Use<\/strong><\/td>Requires boilerplate code for CRUD<\/td>Reduces boilerplate with utility methods<\/td>Uses annotations and repositories for simplicity<\/td><\/tr>
                Error Handling<\/strong><\/td>Manual exception handling<\/td>Automatic translation to Spring exceptions<\/td>Automatic handling of persistence exceptions<\/td><\/tr>
                Transaction Management<\/strong><\/td>Manual management required<\/td>Supports transaction management with Spring<\/td>Built-in transaction handling with @Transactional<\/code><\/td><\/tr>
                Performance<\/strong><\/td>High (direct access)<\/td>High (optimized for batch operations)<\/td>Generally lower due to additional overhead of ORM<\/td><\/tr>
                Mapping<\/strong><\/td>Manual mapping of result sets to objects<\/td>Supports RowMapper<\/code> for custom mapping<\/td>Automatic mapping of entities to database tables<\/td><\/tr>
                Use Cases<\/strong><\/td>Suitable for simple, performance-critical applications<\/td>Good for straightforward JDBC operations<\/td>Best for complex applications requiring rich domain models<\/td><\/tr><\/tbody><\/table><\/figure>\n\n\n\n
                Fazit<\/h5>\n\n\n\n
                • JDBC<\/strong> is suitable for low-level database access where performance is critical, but it requires a lot of boilerplate code.<\/li>
                • JdbcTemplate<\/strong> simplifies JDBC usage by handling resource management and providing utility methods, making it easier to work with databases.<\/li>
                • JPA<\/strong> is ideal for applications that require complex object-relational mapping and a higher level of abstraction, but it comes with additional overhead.<\/li><\/ul>\n\n\n\n
                  Choosing between these options depends on the specific requirements of our application, including complexity, performance, and ease of use.<\/p>\n\n\n\n
                  6. Transactions in Spring<\/h4>\n\n\n\n
                  Spring provides support for declarative transactions, allowing us to manage transactions through annotations.<\/p>\n\n\n\n
                  Example of Transactions<\/h5>\n\n\n\n
                  import org.springframework.stereotype.Service;\nimport org.springframework.transaction.annotation.Transactional;\n\n@Service\npublic class UserService {\n\n    @Autowired\n    private UserRepository userRepository;\n\n    @Transactional\n    public void createUser(User user) {\n        userRepository.save(user);\n        \/\/ Additional operations that are part of the transaction\n    }\n}<\/code><\/pre>\n\n\n\n
                  Conclusion<\/h5>\n\n\n\n
                  This tutorial gives us an overview of the structure of a Spring Boot project, AOP, database access, Spring Data JPA, and transactions. <\/p>\n","protected":false},"excerpt":{"rendered":"
                  1. Structure of a Spring Boot Project The typical structure of a Spring Boot project looks like this: Explanations of the Structure: src\/main\/java: This is where all the Java code resides. com\/example: The base package name, usually reflecting the company’s domain name. controller\/: Contains the REST controllers that handle HTTP requests. service\/: Business logic is […]<\/p>\n","protected":false},"author":1,"featured_media":3403,"comment_status":"open","ping_status":"open","sticky":false,"template":"","format":"standard","meta":[],"categories":[554,868],"tags":[893,889,891,890,892,894],"_links":{"self":[{"href":"https:\/\/nguenkam.com\/blog\/index.php\/wp-json\/wp\/v2\/posts\/3415"}],"collection":[{"href":"https:\/\/nguenkam.com\/blog\/index.php\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/nguenkam.com\/blog\/index.php\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/nguenkam.com\/blog\/index.php\/wp-json\/wp\/v2\/users\/1"}],"replies":[{"embeddable":true,"href":"https:\/\/nguenkam.com\/blog\/index.php\/wp-json\/wp\/v2\/comments?post=3415"}],"version-history":[{"count":4,"href":"https:\/\/nguenkam.com\/blog\/index.php\/wp-json\/wp\/v2\/posts\/3415\/revisions"}],"predecessor-version":[{"id":3426,"href":"https:\/\/nguenkam.com\/blog\/index.php\/wp-json\/wp\/v2\/posts\/3415\/revisions\/3426"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/nguenkam.com\/blog\/index.php\/wp-json\/wp\/v2\/media\/3403"}],"wp:attachment":[{"href":"https:\/\/nguenkam.com\/blog\/index.php\/wp-json\/wp\/v2\/media?parent=3415"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/nguenkam.com\/blog\/index.php\/wp-json\/wp\/v2\/categories?post=3415"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/nguenkam.com\/blog\/index.php\/wp-json\/wp\/v2\/tags?post=3415"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}