DEV Community: Tommy

Spring JPA - @EntityGraph

Tommy — Fri, 02 May 2025 00:43:51 +0000

By default, Spring Data JPA loads related data lazily, which can cause the N+1 problem — one query for the main data and more for each related item. @EntityGraph annotation fixes this by letting you load related data in a single query, without changing your entity mapping. It’s simple, improves performance, and avoids writing custom JOIN FETCH queries.

Example

Let’s say you have a Post entity that references an Author.

Entities

@Entity
public class Post {
    @Id
    private Long id;
    private String title;

    @ManyToOne(fetch = FetchType.LAZY)
    private Author author;
}

@Entity
public class Author {
    @Id
    private Long id;
    private String name;
}

Repository

public interface PostRepository extends JpaRepository<Post, Long> {

    // attributePaths specifies related entities to eagerly load
    @EntityGraph(attributePaths = {"author"})
    List<Post> findAll();
}

Now, if you create a simple controller to return all posts and have SQL logging enabled, you'll see the queries printed in the console.

With @EntityGraph, only one query runs to fetch both the post and its author. Without it, multiple queries are executed — one for the posts and one for each author — which is the N+1 problem.

✅ Using @EntityGraph
Only one query — fast and efficient.

select p.id, p.title, a.id, a.name
from post p
left join author a on p.author_id = a.id

🚨 Not Using @EntityGraph
N+1 queries — slow and wasteful.

select * from post;
select * from author where id = ?;
select * from author where id = ?;

For more details on how to use @EntityGraph with Spring Data JPA, check out the official documentation.

SQL Database Normalization with Easy Examples

Tommy — Sun, 18 Feb 2024 19:17:12 +0000

In database design, there are three main ways to organize data: first normal form (1NF), second normal form (2NF), and third normal form (3NF). While there are more advanced forms like Boyce and Codd Normal Form (BCNF or 3.5NF) and fourth normal form (4NF), we'll focus on the basics: 1NF, 2NF, and 3NF.

Why Normalization is Important?

Normalization is crucial because it prevents anomalies and eliminates redundant data. Anomalies include Update Anomalies, Insertion Anomalies, and Deletion Anomalies.

Update Anomalies: These occur when updating data inconsistently, leading to discrepancies or errors.

Insertion Anomalies: When adding new data, insertion anomalies arise due to the necessity of adding incomplete information because certain attributes depend on other attributes not present.

Deletion Anomalies: Deleting data can inadvertently remove unrelated information due to dependencies within the database.

First Normal Form (1NF):

In 1NF, each column in a table contains atomic values, meaning that each value is indivisible. For example, in a table storing student information, the Phone Numbers column should not contain multiple phone numbers separated by commas.

Instead, each phone number should be in its own row.

Second Normal Form (2NF):

2NF builds on 1NF by ensuring that every non-key attribute is fully dependent on the primary key. In other words, each column must depend on the entire primary key, not just a part of it. For instance, in a table that stores product order details, if the primary key is OrderID, the Gender column should depend on OrderID.

In this case, the Gender column is not fully dependent on the primary key; hence we remove it. This violates the 2NF because the Gender information is not directly related to the primary key.

Third Normal Form (3NF):

3NF further refines the structure by removing transitive dependencies. This means that non-key attributes should not depend on other non-key attributes. In other words, if columns A, B, and C are in a table R, and A determines B, and B determines C, then C is transitively dependent on A.

In this example, the Category column depends solely on the Product Name column creating a transitive dependency and violating the 3NF. Hence, we move them out to separate tables.

Got something? Feel free to use the comment section.

SOLID - Software Design Principles

Tommy — Tue, 13 Feb 2024 17:07:09 +0000

SOLID

is an acronym representing five design principles in software development: Single Responsibility, Open/Closed, Liskov Substitution, Interface Segregation, and Dependency Inversion. These principles aim to create more maintainable, scalable, and understandable software by promoting modular and flexible design.

Let's understand each of them with examples.

Single Responsibility Principle

states that a class should have only one reason to change, meaning it should have only one responsibility or job. In the example below, the Calculator class is responsible for performing arithmetic operations, while the Printer class is responsible for printing results. Each class has a single responsibility, making the code easier to understand and maintain.

public class Calculator {
    public int add(int a, int b) {
        return a + b;
    }
}

public class Printer {
    public void printResult(int result) {
        System.out.println("Result: " + result);
    }
}

Open/Closed Principle

states that software entities (classes, modules, functions, etc.) should be open for extension but closed for modification. In this example, the Shape class is open for extension as new shapes can be added by creating new subclasses like Circle and Rectangle, but it is closed for modification as existing classes don't need to be altered when new shapes are introduced.

public abstract class Shape {
    public abstract double area();
}

public class Circle extends Shape {
    private double radius;

    public Circle(double radius) {
        this.radius = radius;
    }

    public double area() {
        return Math.PI * radius * radius;
    }
}

public class Rectangle extends Shape {
    private double width;
    private double height;

    public Rectangle(double width, double height) {
        this.width = width;
        this.height = height;
    }

    public double area() {
        return width * height;
    }
}

Liskov Substitution Principle

states that objects of a superclass should be replaceable with objects of its subclasses without affecting the correctness of the program. In this example, both Duck and Sparrow are subclasses of Bird, and they override the fly() method according to their own behavior. When substituted for a Bird object, they retain the expected behavior without breaking the program.

class Bird {
    public void fly() {
        System.out.println("Flying");
    }
}

class Duck extends Bird {
    @Override
    public void fly() {
        System.out.println("Flying like a duck");
    }
}

class Sparrow extends Bird {
    @Override
    public void fly() {
        System.out.println("Flying like a sparrow");
    }
}

public class Main {
    public static void main(String[] args) {
        Bird duck = new Duck();
        Bird sparrow = new Sparrow();

        duck.fly(); // Output: Flying like a duck
        sparrow.fly(); // Output: Flying like a sparrow
    }
}

Interface Segregation Principle

states that clients should not be forced to depend on interfaces they do not use. In other words, it suggests that interfaces should be specific to the needs of the clients. In this example, the Printer and Scanner interfaces segregate the behaviors related to printing and scanning respectively. The AllInOnePrinter class implements both interfaces, but other classes can choose to implement only the interface(s) relevant to them.

interface Printer {
    void print();
}

interface Scanner {
    void scan();
}

class AllInOnePrinter implements Printer, Scanner {
    public void print() {
        System.out.println("Printing...");
    }

    public void scan() {
        System.out.println("Scanning...");
    }
}

Dependency Inversion Principle

suggests that high-level modules should not depend on low-level modules but rather both should depend on abstractions. Additionally, it advocates for the use of interfaces or abstract classes to decouple classes and promote flexibility. In this example, the MessageSender class depends on the Message interface rather than concrete implementations like Email or SMS, allowing for easier swapping of message types without modifying the MessageSender class.

interface Message {
    String getContent();
}

class Email implements Message {
    public String getContent() {
        return "This is an email message";
    }
}

class SMS implements Message {
    public String getContent() {
        return "This is an SMS message";
    }
}

class MessageSender {
    private Message message;

    public MessageSender(Message message) {
        this.message = message;
    }

    public void sendMessage() {
        System.out.println("Sending message: " + message.getContent());
    }
}

Some handy PHP Array functions

Tommy — Mon, 05 Feb 2024 09:18:40 +0000

Hey buddy, here are some handy-dandy PHP Array functions for you.

Let's declare an example array

$languages = ["php", "javaScript", "html"];

Sorts the array in ascending order.

sort($languages);

Reverse sorts the array in descending order.

rsort($languages);

Sorts the array by keys in ascending order.

ksort($languages);

Reverse sorts the array by keys in descending order.

krsort($languages);

Sorts the array using a natural case-insensitive algorithm.

natcasesort($languages);

Combines two arrays, using the first as keys and the second as values.

array_combine($languages, [1, 2, 3]);

Merges two or more arrays into a single array.

array_merge($languages, [1, 2, 3], [4, 5, 6]);

Searches for an element in an array and returns its index position.

array_search("PHP", $languages);

Checks if an element exists in an array, returning a boolean value.

in_array("php", $languages);

Checks if a key exists in an array.

array_key_exists(0, $languages);

Adds an element to the end of an array.

array_push($languages, "java");

Adds an element to the beginning of an array.

array_unshift($languages, "vue");

Removes the last element from an array.

array_pop($languages);

Removes the first element from an array.

array_shift($languages);

Adds or removes elements from an array at a specified position. (see optional params in the docs below)

array_splice($languages, 0, 1);

Extracts a portion of an array starting from a specified position. (see optional params in the docs below)

array_splice($languages, 0, 2, 100);

Removes duplicate values from the array.

array_unique($languages);

Returns all keys of the associative array.

array_keys($languages);

Returns all values of the associative array.

array_values($languages);

Flips string and integer values of an associative array.

array_flip($languages);

Shuffles the order of the elements of the array.

shuffle($languages);

Array pointer helper functions
Moves the array's internal pointer to the last element.

end($languages);

Returns the current element's value.

current($languages);

Moves the array's internal pointer to the previous element.

prev($languages);

Moves the array's internal pointer to the next element.

next($languages);

Got more? Feel free to add in the comment section below.

Doc
https://www.php.net/manual/en/ref.array.php

Some handy PHP String functions

Tommy — Sun, 28 Jan 2024 12:14:56 +0000

Hey buddy, here are some handy-dandy PHP String functions for you.

heredoc is a way to declare strings using a special syntax, allowing multiline strings without needing to escape quotes.

echo <<<"FOOBAR"
Hello World!
FOOBAR;

nowdoc is kinda similar to heredoc but treats the enclosed string literally, ignoring variables and special characters.

echo <<<'EOD'
Example of string spanning multiple lines
using nowdoc syntax. Backslashes are always treated literally,
e.g. \\ and \'.
EOD;

Get the length of a string

echo strlen($str1);

Convert a string to lowercase

echo strtolower($str1);

Convert a string to uppercase

echo strtoupper($str1);

Uppercase the first character of a string

echo ucfirst($str1);

Uppercase the first character of each word in a string

echo ucwords($str1);

Get a substring from a string starting at index 6

echo substr($str1, 6);

Get a substring from a string starting at index 6 with a length of 4

echo substr($str1, 6, 4);

Find the position of a substring in a string (case-sensitive)

echo strpos($str1, "Hello");

Find the position of a substring in a string (case-insensitive)

echo stripos($str1, "hello");

Convert an array into a string using implode

$arr1 = [1, "two"];
print_r(implode($arr1));

Convert a string into an array using explode

print_r(explode("@foo", $str1));
$str2 = "lol#oof#sheez";
print_r(explode("#", $str2));

Replace a substring in a string

$str2 = "welcome back!"; 
echo str_replace("back", "home", $str2);

Remove HTML tags from a string

$html_text_content = "<p>lol</p>";
echo strip_tags($html_text_content);

Escape special characters in a string

$name = "tom's world";
echo addslashes($name);

Remove slashes from a string

$str_with_slashes = "\yes \sir";
echo stripslashes($str_with_slashes);

Trim white spaces from the beginning and end of a string

$str_with_spaces = "    no!   ";
echo trim($str_with_spaces);

Shuffle characters in a string

$shuffle_me = "hello there!";
echo str_shuffle($shuffle_me);

Generate and display a 6-character OTP

$otp = "1726341237472364782346253";
echo substr(str_shuffle($otp), 0, 6);

Use md5 to a string (not recommended for password hashing)

$pwd = "password123";
echo md5($pwd);
echo password_hash($pwd, PASSWORD_DEFAULT);

Verify a password hash

$hash = '$2y$10$.vGA1O9wmRjrwAVXD98HNOgsNpDczlqm3Jq7KnEd1rVAGv3Fykk1a';
if (password_verify('rasmuslerdorf', $hash)) {
    echo 'Password is valid!';
} else {
    echo 'Invalid password.';
}

Encode and decode strings to/from base64

$str3 = "test";
echo base64_encode($str3);
echo base64_decode("dGVzdA==j");

Do you have something more to add? Feel free to add them in the comment section to help other devs.

What's @SpringBootApplication Annotation?

Tommy — Fri, 03 Feb 2023 02:21:52 +0000

In a nutshell, @SpringBootApplication is a convenience annotation that is equivalent to declaring three separate annotations @Configuration, @EnableAutoConfiguration, and @ComponentScan with their default attributes. It is typically used on the main class of a Spring Boot application to enable auto-configuration, component scanning, and to define the application context.

@Configuration: Indicates that the class is a source of bean definitions for the application context.
@EnableAutoConfiguration: Enables Spring Boot's auto-configuration mechanism, which automatically configures the application based on the dependencies that are added in the classpath.
@ComponentScan: Enables component scanning so that the annotated components are automatically discovered and registered as beans in the application context.

By using the @SpringBootApplication annotation, developers can write less code and make their code easier to read and understand.

ex:

package com.example.myapplication;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication // same as @Configuration @EnableAutoConfiguration @ComponentScan
public class Application {

    public static void main(String[] args) {
        SpringApplication.run(Application.class, args);
    }

}

Spring Autowiring

Tommy — Wed, 01 Feb 2023 02:18:35 +0000

Spring Autowiring is a feature of the Spring Framework that allows for the automatic injection of dependencies between beans in a Spring application. It allows developers to define the dependencies of a bean in the configuration file, rather than hard-coding them in the bean's class.

Autowiring can greatly simplify the process of creating and configuring beans in a Spring application, making it easier to manage dependencies and improve code maintainability.

How to autowire beans?

XML Configuration: Autowiring can be specified in XML configuration files by setting the "autowire" attribute on the definition to one of the autowiring modes, such as "byType" or "byName".

<bean id="exampleBean1" class="com.example.ExampleBean1" autowire="byType"/>

<bean id="exampleBean2" class="com.example.ExampleBean2" autowire="byName"/>

<bean id="exampleBean3" class="com.example.ExampleBean3"/>

Java Configuration: Autowiring can be specified in Java configuration files by using the @Autowired annotation on the setter methods or fields that should be autowired. Alternatively, you can use the @Autowired constructor to autowire by constructor. In the example below, we annotate the fields.

@Component
public class ExampleConfig {

  @Autowired
  private ExampleBean1 exampleBean1;

  // You can use @Qualifier annotation along with @Autowired to autowire beans by name.
  @Autowired
  @Qualifier("exampleBean2")
  private ExampleBean2 exampleBean2;

...

The default autowiring mode in Java configuration is "byType", while in XML configuration, it is set to "no".

Autowiring Modes:

Autowiring modes are different ways in which the Spring framework can wire beans together automatically.

autodetect: When autowiring is set to "autodetect", Spring framework will first look for a constructor to resolve the bean dependencies, and if a constructor is not found, it will fall back to using the "byType" mode.
no: When autowiring is set to "no", it means that the beans are not wired together automatically and the developer must manually specify the dependencies between the beans in the configuration. This mode provides the greatest degree of control over how beans are wired together, but it also requires the most effort on the part of the developer.
byName: This mode looks for a bean with the same name as the property that is being set. For example, if a class has a property called "processor", the Spring container will look for a bean named "processor" and wire it to the property.
byType: This mode looks for a bean of the same type as the property that is being set. For example, if a class has a property of type "Processor", the Spring container will look for a bean of type "Processor" and wire it to the property.
constructor: Autowiring can also be done on constructors, in which case the Spring container will look for beans of the same type as the constructor arguments and wire them to the constructor.

Spring Bean

Tommy — Tue, 31 Jan 2023 21:20:35 +0000

Spring Bean

A Spring Bean is an object managed by the Spring framework. It is created by the Spring IoC container and is managed throughout the lifecycle of an application.

How to Create a Spring Bean?

A Spring Bean can be defined using XML configuration and annotations. In the examples below, we will use annotations since these have become a very common and modern way of defining a bean in Spring framework. Annotation-based configuration provides a more concise and easy-to-read way of defining beans, compared to traditional XML-based configuration.

The most common annotations used for defining a bean are @Component, @Service, @Repository, @Controller and @bean.

@Component is a general-purpose, class-level stereotype annotation that indicates that a class is a component in the Spring application. The @Component annotation can be used to mark any class as a candidate for auto-detection as a Spring Bean.

@Component
public class Employee {
   // ...
}

@Controller is a specialization of @Component that is used to indicate that a class is a controller component. The @Controller annotation is used to mark a class that provides HTTP request handling services.

@Controller
public class EmployeeController {
   // ...
}

@Service is a specialization of @Component that is used to indicate that a class is a service component. The @Service annotation is used to mark a class that provides business logic services.

@Service
public class EmployeeService {
   // ...
}

@Repository is a specialization of @Component that is used to indicate that a class is a repository component. The @Repository annotation is used to mark a class that provides data access services.

@Repository
public interface EmployeeRepository extends CrudRepository<T, ID>{
   // ...
}

@bean annotation is used to define a bean in Spring framework, specifically in a Java configuration class. This a method-level annotation that is used in conjunction with the @Configuration annotation to define beans and manage their lifecycle within the Spring IoC container. Notice that the body of the method contains the logic responsible for creating the instance.

@Configuration
public class AppConfig {

   @Bean
   public EmployeeService employeeService() {
      return new EmployeeService();
   }
}

Spring Bean Scope

Spring Beans have several different scopes that define the lifecycle and scope of the bean within the Spring IoC container. The most common scopes are:

Singleton: This is the default scope for a Spring Bean, and it means that there is only one instance of the bean in the IoC container. This instance is shared by all objects that request it.
Prototype: A prototype scope means that a new instance of the bean is created each time it is requested. This is useful for beans that are stateful or have a large amount of data.
Request: This scope is used for beans that are associated with an HTTP request. A new instance of the bean is created for each request, and the bean is only accessible within the scope of that request.
Session: This scope is used for beans that are associated with an HTTP session. A new instance of the bean is created for each session, and the bean is only accessible within the scope of that session.
Global Session: This scope is used for beans that are associated with a global HTTP session, typically in a Portlet context.

Spring Bean vs Java Bean

A Java Bean is a simple Java class that follows certain conventions, such as having a no-arg constructor, private fields, and public getter and setter methods for accessing those fields. Java Beans are often used to store data and transfer data between different parts of an application.

// example of a Java bean

public class Employee {
   private String name;
   private int age;

   // No-arg constructor
   public Employee() { }

   // Getters and Setters
   public String getName() { return name; }
   public void setName(String name) { this.name = name; }

   public int getAge() { return age; }
   public void setAge(int age) { this.age = age; }
}

In this example, the Employee class is a simple Java Bean that follows the conventions of having a no-arg constructor, private fields, and public getter and setter methods.

A Spring Bean, on the other hand, is an object managed by the Spring framework, specifically by the Spring IoC (Inversion of Control) container. A Spring Bean is created by the IoC container and is managed throughout the lifecycle of an application. It can be a simple Java Bean, but it is also commonly used to represent services, repositories, controllers, and other types of components within a Spring-based application.

// example of a Spring Bean

@Service
public class EmployeeService {
   private EmployeeDao employeeDao;

   @Autowired
   public EmployeeService(EmployeeDao employeeDao) {
      this.employeeDao = employeeDao;
   }

   public List<Employee> getAllEmployees() {
      return employeeDao.findAll();
   }
}

In this example, the EmployeeService class is a Spring Bean that is annotated with @Service. This annotation marks the class as a service component, and it will be automatically discovered and managed by the Spring IoC container. The EmployeeService class also has a constructor that is annotated with @Autowired, which will allow Spring to inject an instance of EmployeeDao into the bean when it is created.

Spring Dependency Injection, IoC and Autowiring

Tommy — Tue, 31 Jan 2023 19:43:03 +0000

What's Dependency Injection (DI)?

Dependency Injection (DI) is a design pattern that implements the principles of Inversion of Control (IoC) by providing an object with its required dependencies from an external source instead of having the object create or locate them on its own. This not only improves code maintainability, flexibility, and testability, but also follows the IoC concept of shifting control from the object to the external dependencies, thereby decoupling the object from its dependencies and promoting modularity

What is IoC?

Inversion of control (IoC) is a general concept that refers to a program or system where the control flow of a program is determined by a framework or container, rather than by the program itself. In Spring, IoC is achieved through dependency injection.

In Spring, there is an implementation known as the IoC container, which connects the dependencies, locates, and manages the life cycle of beans. The Spring IoC container is represented by ApplicationContext, which is responsible for creating, setting up, and putting together the beans mentioned. The container follows the instructions for which objects to create, configure, and assemble from the configuration metadata it reads.

What is Autowiring?

In the context of Spring, Autowiring can be used to implement Dependency Injection. When you enable Autowiring for a bean, the Spring framework will automatically resolve and wire the dependencies for that bean, using one of the DI techniques, such as Constructor-based, Setter-based, or Field-based Dependency Injection.

In other words, Autowiring is a way to simplify the process of implementing Dependency Injection in Spring. By using Autowiring, you can eliminate the need to explicitly specify the relationships between beans in the configuration file, allowing you to make changes to your code more easily.

In this example, we will use the @Autowired annotation to enable Autowiring in Spring.

The 3 types of Dependency Injection in Spring are:

Constructor-based Dependency Injection: The dependencies are provided to an object via constructors.

public class MyService {
   private MyDependency myDependency;

   // constructor injection
   @Autowired
   public MyService(MyDependency myDependency) {
      this.myDependency = myDependency;
   }
}

Setter-based Dependency Injection: The dependencies are provided to an object via setter methods.

public class MyService {
   private MyDependency myDependency;

   @Autowired
   public void setMyDependency(MyDependency myDependency) {
      this.myDependency = myDependency;
   }
}

Field-based Dependency Injection: The dependencies are provided to an object via fields.

public class MyService {
   @Autowired
   private MyDependency myDependency;
}

Recursive Algorithm

Tommy — Sun, 05 Jun 2022 14:49:48 +0000

Recursion is where a function invokes itself. Various algorithms utilize recursion, hence it's important to know this concept.

Always remember when creating a recursive function that you need 2 parts: the base case, and the recursive case. The recursive case is when the function calls itself. The base case is when the function doesn’t call itself again (this prevents the function go into an infinite loop)

Sample Code

In this example, we try to find the factorial of 5

public class Main {
    public static void main(String[] args) {
        // test the recursion method
        Factorial f = new Factorial();
        System.out.println(f.recursion(5));
    }
}

class Factorial {
    public long recursion(long n) {
        // this is our base case
        // always have a base case or else your recursion will never end
        if (n <= 1) {
            // here we are returning a value of 1
            // in programming, this means the output is met or valid
            return 1;
        } else {
            //recrusive case or also known as the method calling itself
            return n * recursion(n - 1);
        }
    }
}

Note:

Be careful with recursion as it can consume a lot of memory, and can create a program that never terminates. However, when used correctly recursion can be a very efficient and mathematically-elegant approach to programming.
There’s no performance benefit to using recursion; in fact, loops are sometimes better for performance. Simply choose which is more important in your situation!

Hibernate - @Formula

Tommy — Mon, 30 May 2022 02:15:04 +0000

Formula Annotation

The @Formula annotation is used to calculate the dynamic value of a property. @Formula takes an expression (this could be simple expression or a complex query) as a parameter. During fetch time, it evaluates the expression and assigns the evaluated value to the property.

Examples

// ex 1
@Formula("lower(datediff(curdate(), birth_date / 365)")
private int age;

// ex 2
@Formula("(select min(s.survey) from statistics s) ")
private float total;

// ex 3
private int num1;
private int num2;
private int num3;

@Formula(" num1 + num2 + num3")
private float totalSum;

Note:
-This is only inserted in a SELECT clause!
-Be careful when using this because the SQL command you may be using may be vendor specific. In other words, this will create coupling with a particular SQL vendor.

Spring AOP - Reusable Pointcut Expressions

Tommy — Mon, 30 May 2022 01:16:03 +0000

Pointcut

A pointcut is a collection of one or more joinpoints where an advice should be invoked. You can declare pointcuts utilizing expressions or patterns like you'll see in the examples below.

Syntax

@Pointcut(" execution(modifiers? return-type declaring-type? method-name(param) throws?) ")

the pattern is optional if it has a ? symbol
patterns can use wildcards * (matches everything)
the @Pointcut annotation contains a set of one or more JoinPoints where an advice should be executed
modifiers? (optional) is the method's access modifier like public, protected, private
return-type is the method's return type
declaring-type? (optional) is the package or class name
method-name(param) is the method's name with its parameters
param could take zero or more arguments. () matches a method that takes no parameters, whereas (..) matches any number of parameters (zero or more). The pattern (*) matches a method taking one parameter of any type
throws? (optional) is the exception type

Combining Pointcut Expressions

You can combine pointcut declarations using:
&&, ||, ! operators

Examples

Declare pointcut methods (must not have a body)

@Pointcut("execution(public * dev.company.*.service.*.get*(..))")
public void pointCutTemplateServiceForGet() {}

@Pointcut("execution(public * dev.company.*.service.*.post*(..))")
public void pointCutTemplateServiceForPost() {}

@Pointcut("execution(public * dev.company.*.service.*.delete*(..))")
public void pointCutTemplateServiceForDelete() {}

Reuse a pointcut
In this example, we use the pointcut template pointCutTemplateServiceForGet() twice for two different advice

@Before("pointCutTemplateServiceForGet()")
// implementation goes here

@After("pointCutTemplateServiceForGet()")
// implementation goes here

Combine multiple pointcuts using &&

@After(pointCutTemplateServiceForGet() && pointCutTemplateServiceForPost())
// implementation goes here

Exclude a pointCut using !

@Before(pointCutTemplateServiceForGet() && !(pointCutTemplateServiceForDelete()))
// implementation goes here

Exclude multiple pointcuts

@Before(pointCutTemplateServiceForDelete() && !(pointCutTemplateServiceForGet() || pointCutTemplateServiceForPost()))
// implementation goes here

There are many more possibilities when mixing and matching pointcut expressions, but I'll leave it up to your imagination.

See this article to learn more about Spring AOP.