Spring AOP self injection makes other autowired/injected objects null - spring

I am try to log time using Spring AOP.
The Logging AOP looks like:
public class TimeLogger2 {
#Pointcut("execution(* com.exercise.spring.aop.service..*(..))")
private void anyOperationInControllerPackage() {
/* nothing to do here;
* this just defines that we want to catch all methods
* in the controller-package
*/
}
#Around("anyOperationInControllerPackage()")
public Object logAround(ProceedingJoinPoint joinPoint) throws Throwable {
System.out.println("Entering " + joinPoint.getSignature().getDeclaringTypeName() + "#" + joinPoint.getSignature().getName() + "() using arguments: " + Arrays.toString( joinPoint.getArgs() ) );
try {
Object result = joinPoint.proceed();
System.out.println("Leaving " + joinPoint.getSignature().getDeclaringTypeName() + "#" + joinPoint.getSignature().getName() + "()." );
return result;
} catch (Throwable ex) {
ex.printStackTrace();
throw ex;
}
}
}
package com.exercise.spring.aop.service;
import ....
#Service
public class MyService {
private TestService testService;
#Autowired
MyService self;
public MyService(TestService testService){
this.testService = testService;
}
public void mymethod(){
self.sample2();
}
private void sample2(){
System.out.println("Inside Sample2" + testService);
}
}
As you can see the "self" variable is used for self injection.
The logging works fine, but if i try to access any autowired objects like testService in the method sample2(), it is null.
How can I access the testService which is autowired in this example?
Thanks

Related

Spring-boot AOP advice with CompletableFuture

I try to log with AOP for a CompletableFuture controller. #Before advice is working OK. But with #AfterReturning it is not working correctly in the exception case. I also tried with #AfterThrowing, which is not working either. When an exception occurs, my #AfterReturning advice also is not triggered and #AfterThrowing is never reached.
How can I use an AOP advice with exceptions in this case?
JController:
#RestController
public class JController extends BaseExceptionHandler {
#GetMapping(produces = MediaType.APPLICATION_JSON_UTF8_VALUE)
public CompletableFuture<BaseResponse> search() {
final CompletableFuture result = asyncProcessor.process(request);
return result;
}
}
BaseExceptionHandler:
public class BaseExceptionHandler {
#ExceptionHandler(Exception.class)
public ResponseEntity handleException(final Exception exception) {
return new ResponseEntity<>(new ErrorResponse(Message.INTERNAL_SERVER_ERROR, StatusCode.UNKNOWN_ERROR), HttpStatus.INTERNAL_SERVER_ERROR);
}
}
AOP Class
#AfterReturning(value = "execution(* com.xxx.xxx.controller.*.*(..))", returning = "result")
public void outgoingSuccess(final JoinPoint joinPoint, final CompletableFuture result) {
LOGGER.debug("After Returning method: " + joinPoint.getTarget().getClass().getSimpleName());
}
#AfterThrowing("execution(* com.xxx.xxx.controller.*.*(..))")
public void outgoingError(final JoinPoint joinPoint) {
LOGGER.debug("After Throwing method: " + joinPoint.getTarget().getClass().getSimpleName());
}

Spring AOP Cannot work for #Around

I am currently working on AOP but some how the AOP cannot working, The #around is not invoking after and before the execution on specific controller.Folloeing is my code.
// my controller
package com.rest.controllers;
class ManCon{
#PostMapping(EndPointReferrer.UPDATE_DEALER_SCHEME_MAPPING_DETAILS)
public ResponseEntity<BaseResponse> updateDealerSchemeMappingDetails(
#RequestBody #NotNull #Valid Myclass obj){
return null;
}
}
//configuration
#Configuration
#EnableAspectJAutoProxy(proxyTargetClass = true)
#ComponentScan(basePackages = {"com.aop"})
public class AOPConfiguration {
#Bean(autowire = Autowire.BY_TYPE)
public SchemeMappingPortalAspect schemeMappingPortalAspect(){ return new SchemeMappingPortalAspect(); }
}
//Aspect
#Aspect
public class SchemeMappingPortalAspect {
private static final org.slf4j.Logger logger = LoggerFactory.getLogger(SchemeMappingPortalAspect.class);
#Pointcut("execution(* com.rest.controllers.ManCon.updateDealerSchemeMappingDetails(..))")
public void schemeMappingPointcut(){
}
/*
* This is used for scheme mapping portal loging
* */
#Around(value = "schemeMappingPointcut()")
public Object loggingSchemePortalDetail(ProceedingJoinPoint joinPoint) throws Throwable{
logger.debug("-------------------------");
logger.debug("In before calling");
logger.debug("-------------------------");
Object o=null;
try {
o= joinPoint.proceed();
System.out.println("JSON::"+ new Gson().toJson(o));
}catch (Exception e){
e.printStackTrace();
}
logger.debug("-------------------------");
logger.debug("In After Calling");
logger.debug("-------------------------");
return o;
}
}

Spring Aspect on Converter

I created simple Aspect an annotation for measuring time of execution of annotated method.
When I annotate method of a simple Spring Bean, inject bean, and run it like bean.annotatedMethod(), everything works fine.
However, when I annotate convert() method on Spring Converter, annotation is ignored. I'm guessing the reason is that convert() is called internally by Spring's ConversionService, and somehow Aspects are not respected. Is there any way to get it to work?
Annotation:
#Retention(RetentionPolicy.RUNTIME)
#Target(ElementType.METHOD)
public #interface LogExecTime {
}
Aspect, which I register in Spring:
#Aspect
#Component
public class LogTimeAspect {
#Around(value = "#annotation(annotation)")
public Object LogExecutionTime(final ProceedingJoinPoint joinPoint, final LogExecTime annotation) throws Throwable {
final long startMillis = System.currentTimeMillis();
try {
System.out.println("Starting timed operation");
final Object retVal = joinPoint.proceed();
return retVal;
} finally {
final long duration = System.currentTimeMillis() - startMillis;
System.out.println("Call to " + joinPoint.getSignature() + " took " + duration + " ms");
}
}
}
This works fine:
#Component
public class Operator {
#LogExecTime
public void operate() throws InterruptedException {
System.out.println("Performing operation");
Thread.sleep(1000);
}
}
#Bean
protected Void test(Operator o) {
o.operate();
return null;
}
But here, annotation is ignored:
public class SampleConverter implements Converter<SourceType, ResultType> {
#Override
#LogExecTime
public ImmutableData convert(#Nonnull ClassifiedEvent result) {
...
}
}
ConversionService conversionService;
...
conversionService.convert(source, ResultType.class));
Solved by comment of #EssexBoy, my converter was not a spring managed bean.

Spring AOP with custom annotation on #Bean method

I'm trying to use AOP with annotation triggering as you can see in this pointcut
package mypackage.aop;
// ...
#Aspect
#Component
public class ErrorHandlerAspect {
private final static Logger LOGGER = LoggerFactory.getLogger(ErrorHandlerAspect.class);
#Pointcut("within(mypackage.config.steps..*) && #annotation(mypackage.aop.SaveAndErrors)")
private void pointcut(){ }
#Around("pointcut()")
private Object errorHandler(ProceedingJoinPoint pjp) throws Throwable{
try{
return pjp.proceed();
} catch (Throwable e){
LOGGER.error("Handling error");
throw e;
}
}
}
Here are declaration of annotation :
package mypackage.aop;
// ...
#Target(ElementType.METHOD)
#Retention(RetentionPolicy.RUNTIME)
public #interface SaveAndErrors { }
... and usage in #Configuration class (for spring batch step configuration) :
package mypackage.config.steps;
// ...
#Configuration
public class StepConfiguration {
public final static String STEP_NAME = "xStep";
// ...
#SaveAndErrors
#Bean(name="xFileReader")
#StepScope
public ItemStreamReader<Object> xFileReader(#Value("#{stepExecutionContext['fileName']}") String resourceName // Inside a partitionner) throws xException {
try {
// ...
// return ...
} catch (yException e) {
throw new xException("new Exception :", e);
}
}
// ...
}
And my Application class :
#SpringBootApplication
public class Application { //...
}
Unfortunately, this is not working.
Removing && #annotation(mypackage.aop.SaveAndErrors) from pointcut, my aop proxy is working.
Where is the mistake?

Get parent bean in prototype bean that gets injected

I would like to have a Bean and a SubBean like this:
#Scope(BeanDefinition.SCOPE_PROTOTYPE)
#Component
public class SubBean implements ApplicationContextAware{
private Object parent;
public void setApplicationContext(ApplicationContext ctx){
this.parent = doSomeMagicToGetMyParent(ctx);
}
public Object getParent(){
return parent;
}
}
#Component
public class SomeBean implements InitializingBean{
#Resource
private SubBean sub;
public void afterPropertiesSet(){
Assert.isTrue(this == sub.getParent());
}
}
The trick I want to achieve is, that the SubBean automagically gets a reference to the Bean it got injected into. Because the scope of the subbean is prototype, it will get injected as a new instance in every parent that wants it to get injected.
My big idea is to exploit this pattern to write a LoggerBean which can be injected into normal beans. The subbean should work just like a SLF4J Logger.
So does anyone know the magic to make this work? :)
EDIT: I've found a solution to do this with a custom BeanPostProcessor:
#Component
public class DependencyInjectionAwareBeanPostProcessor implements BeanPostProcessor {
#Override
public Object postProcessBeforeInitialization(Object bean, String beanName) {
return bean;
}
#Override
public Object postProcessAfterInitialization(Object bean, String beanName) {
for (Field f : bean.getClass().getFields()) {
if (f.getType().isInstance(IDependencyInjectionAware.class)) {
ReflectionUtils.makeAccessible(f);
try {
IDependencyInjectionAware diAware = (IDependencyInjectionAware) f.get(bean);
diAware.injectedInto(bean);
} catch (IllegalArgumentException e) {
ReflectionUtils.handleReflectionException(e);
} catch (IllegalAccessException e) {
ReflectionUtils.handleReflectionException(e);
}
}
}
return bean;
}
}
Here is the Interface:
public interface IDependencyInjectionAware {
void injectedInto(Object parent);
}
And here a Bean using it:
#Scope(BeanDefinition.SCOPE_PROTOTYPE)
#Component
public class SomeAwareBean implements IDependencyInjectionAware {
private Object parent;
public void injectedInto(Object parent){
this.parent = parent;
}
public Object getParent(){
return parent;
}
}
Here a test with a normal Bean which works perfectly:
#Component
public class UsingBean implements InitializingBean {
#Resource
private SomeAwareBean b;
public void afterPropertiesSet(){
Assert.notNull(b); //works
Assert.isTrue(b.getParent() == this); //works
}
}
Though, when using the same with a normal class which gets the depedencies injected via #Configurable, the test fails:
#Configurable
public class UsingPlainClass implements InitializingBean {
#Resource
private SomeAwareBean b;
public void afterPropertiesSet(){
Assert.notNull(b); //works
Assert.isTrue(b.getParent() == this); //fails because null is returned
}
}
So this seems to have gotten me to another question: Why won't my custom BeanPostProcessor run on a #Configurable classes? Maybe I have to resort to AspectJ afterall...
EDIT: Just to update the status. I did not implement this afterall because this is overengineering...
I find this simpler:
#Scope(BeanDefinition.SCOPE_PROTOTYPE)
#Component
public class SubBean implements ApplicationContextAware{
private Object parent;
public void setApplicationContext(ApplicationContext ctx){
...
}
public Object getParent(){
return parent;
}
//ADDED CODE
public void setParent(Object parent) {
this.parent = parent;
}
//END ADDED CODE
}
#Component
public class SomeBean implements InitializingBean{
private SubBean sub;
//ADDED CODE
#Resource
public void setSub(SubBean sub) {
this.sub = sub;
sub.setParent(this);
}
//END ADDED CODE
public void afterPropertiesSet(){
Assert.isTrue(this == sub.getParent());
}
}
Fixed several bugs with the solution given by the original poster:
import java.lang.reflect.Field;
import org.apache.log4j.Logger;
import org.springframework.beans.factory.config.BeanPostProcessor;
import org.springframework.util.ReflectionUtils;
public interface DependencyInjectionAware {
void injectedInto(final Object bean, final String beanName);
public static class DependencyInjectionAwareBeanPostProcessor implements
BeanPostProcessor {
private static final Logger logger = Logger.getLogger(DependencyInjectionAwareBeanPostProcessor.class);
#Override
public Object postProcessBeforeInitialization(final Object bean,
final String beanName) {
return bean;
}
#Override
public Object postProcessAfterInitialization(final Object bean,
final String beanName) {
for (final Field f : bean.getClass().getDeclaredFields()) {
logger.info("scanning field " + f.getName() + " of bean " + beanName + " (class= " + bean.getClass() + ")");
if (DependencyInjectionAware.class.isAssignableFrom(f.getType())) {
ReflectionUtils.makeAccessible(f);
try {
final DependencyInjectionAware diAware = (DependencyInjectionAware) f.get(bean);
diAware.injectedInto(bean, beanName);
} catch (final IllegalArgumentException e) {
ReflectionUtils.handleReflectionException(e);
} catch (final IllegalAccessException e) {
ReflectionUtils.handleReflectionException(e);
}
}
}
return bean;
}
}
}

Resources