Cfrgtkky

I want to write common code which should be execute before every method,
Where can I place this code in spring.

Thanks in advance.

You should have a look at Spring AOP. With Spring AOP you can write Aspects which can be common code which is executed before/after a method. The following example is a simple Aspect:

@Aspect

public class EmployeeAspect {



    @Before("execution(public String getName())")

    public void getNameAdvice(){

        System.out.println("Executing Advice on getName()");

    }



    @Before("execution(* your.package.name.*.get*())")

    public void getAllAdvice(){

        System.out.println("Service method getter called");

    }

}

Within the @Before() annotation you can specify the exact method which is surrounded with the Aspect or you use the wildcard * to specify more methods. For this, you should be familiar with Pointcut expressions.

What you ask is not trivial but Aspect Oriented Programming (AoP) is one way to achieve that. This description assumes that you are somewhat familiar with the Proxy class, the InvocationHandler interface and the Interceptor pattern in general. As I said, not a totally trivial matter.

1. 
   

   Define the logic that you what to be executed before every method, or some method or whatever. Usually it is come kind of Interceptor, this is an example:

   
   
   

   public class TimeProfilerInterceptor implements MethodInterceptor {
   
   
   
       @Getter
   
       private final TimeStatistics statistics = new TimeStatistics();
   
   
   
       @Override
   
       public Object invoke(MethodInvocation invocation) throws Throwable {
   
           StopWatch watch = new StopWatch();
   
           try {
   
               watch.start();
   
               Object returnValue = invocation.proceed();
   
               return returnValue;
   
           }
   
           finally {
   
               // etc...
   
           }
   
       }
   
   }
   
   

   
   


2. 
   

   Define a place where your logic is wired to your methods. In this example, the place is a Spring component that extends AbstractBeanFactoryAwareAdvisingPostProcessor and implements InitializingBean. The afterPropertiesSet method is called by Spring once the initialization of the bean is done. The method uses the Advice class from spring-aop to identify the pointcuts i.e. the methods that must be wrapped by the interceptor. In this case, it is an annotation based pointcut, meaning that it matches every method that has a certain custom annotation on it (TimeProfiled).

   
   
   

   @Component
   
   public class TimeProfiledAnnotationPostProcessor 
   
           extends AbstractBeanFactoryAwareAdvisingPostProcessor 
   
           implements InitializingBean {
   
   
   
       @Autowired
   
       TimeProfilerInterceptor timeProfilerInterceptor;
   
   
   
       @Override
   
       public void afterPropertiesSet() throws Exception {
   
           this.setProxyTargetClass(true);
   
           Advice advice = timeProfilerInterceptor;
   
           Pointcut pointcut = new AnnotationMatchingPointcut(null, TimeProfiled.class);
   
           this.advisor = new DefaultPointcutAdvisor(pointcut, advice);
   
       }
   
   }
   
   

   
   


3. 
   

   Define your custom annotation to use where needed.

   
   
   

   @Target(ElementType.METHOD)
   
   @Retention(RetentionPolicy.RUNTIME)
   
   public @interface TimeProfiled {
   
   
   
   }
   
   

   
   


4. 
   

   Tell Spring to initiate the wrapping mechanism at startup via the following annotation upon a Spring Configuration or a SpringBootApplication:

   
   
   

   @ComponentScan(basePackageClasses = TimeProfiledAnnotationPostProcessor.class)
   
   @EnableAspectJAutoProxy(proxyTargetClass = true)
   
   

   
   

You can change the pointcut so that it matches other methods with other criteria, there is an entire syntax to do that, a world in itself, this is just a small example...