Frühling AOP-Proxy

Question

Mein Code: -

<context:annotation-config/> 
    <bean id="arthmeticCalculator" class="com.manoj.aop.test.CalculatorImpl" lazy-init="true"/> 
    <bean id="stubCalculator" class="com.manoj.aop.test.StubCalculator" lazy-init="true"/> 
    <bean class="org.springframework.aop.framework.autoproxy.BeanNameAutoProxyCreator"> 
     <property name="beanNames"> 
     <list> 
      <value>*Calculator</value> 
     </list> 
     </property> 
     <property name="interceptorNames"> 
     <list> 
      <value>methodNameAdvisor</value> 
     </list> 
     </property> 
    </bean> 
    <bean id="methodNameAdvisor" 
     class="org.springframework.aop.support.NameMatchMethodPointcutAdvisor"> 
    <property name="mappedNames"> 
     <list> 
     <value>add</value> 
     <value>sub</value> 
     </list> 
    </property> 
    <property name="advice" ref="loggingAroundAdvice" /> 
    </bean> 
    <bean id="loggingAroundAdvice" class="com.manoj.aop.test.LoggingAroundAdvice"> 
     <constructor-arg><ref bean="arthmeticCalculator"/></constructor-arg> 
     <constructor-arg><ref bean="stubCalculator"/></constructor-arg> 
     <constructor-arg><value>false</value></constructor-arg> 
    </bean> 
    <bean id="testService" class="com.manoj.aop.test.TestService"> 
    <!-- 
     <property name="arthmeticCalculator" ref="arthmeticCalculator"/> 
    --> 
    </bean> 

Java-Code:

package com.manoj.aop.test; 

import org.aopalliance.intercept.MethodInterceptor; 
import org.aopalliance.intercept.MethodInvocation; 
import org.springframework.beans.factory.annotation.Autowired; 
import org.springframework.beans.factory.annotation.Qualifier; 
import org.springframework.beans.factory.annotation.Value; 

public class LoggingAroundAdvice implements MethodInterceptor{ 


     Calculator actualCalculator; 
     Calculator stubCalculator; 
     boolean useStub; 



public LoggingAroundAdvice(Calculator actualCalculator, Calculator stubCalculator, boolean useStub) { 
    this.actualCalculator = actualCalculator; 
    this.stubCalculator = stubCalculator; 
    this.useStub = useStub; 
    } 



public Object invoke(MethodInvocation methodInvocation) throws Throwable { 
    System.out.println("Around Invoice called"); 
    Calculator calc = useStub ? stubCalculator: actualCalculator; 
    System.out.println(calc.getClass().getName()); 
    Object result = methodInvocation.getMethod().invoke(calc, methodInvocation.getArguments()); 
    return result; 
} 

} 

import org.springframework.beans.factory.annotation.Autowired; 

public class TestService { 

@Autowired 
    private Calculator arthmeticCalculator; 


    public void test(){ 
     System.out.println(arthmeticCalculator.getClass().getName()); 
     System.out.println(arthmeticCalculator.add(5, 10.5)); 
    } 



} 

Sorry Leute ich weiß nicht, wie Text in diesem Editor zu formatieren, Mein Problem ist: -

Spring erstellt einen Proxy für die Klasse, führt jedoch niemals die Invoke-Methode des Around-Hinweises aus. Kann mir ein Körper bitte sagen, was los ist und wie man die Aufrufmethode aufruft? Hier

ist der Ausgang der Testklasse: -

$ Proxy4 15.5

Danke, Manoj

Answer 1

Welche Version von Spring verwenden Sie? Die Art und Weise, wie Sie Proxy machen, ist der ältere Weg. Der bessere Weg ist die Annotation oder der reine POJO + XML-Weg. Sie können eine kurze Einführung in AOP Abschnitt here