Primavera / Springboot Error al analizar comentario

La razón notas Primavera / Springboot no logran resolver

Fenómeno: primavera señala el fracaso de un fracaso seguro transacción
razón: Spring AOP se lleva a cabo para mantener un objeto proxy, la primera invocación de método objeto proxy, si se llama al otro lado de la clase directamente en este proceso, lo hará otra forma de mejorar la causa de la falla, debido principalmente a la segunda llamada es un objeto proxy para llamar.
código de ejemplo insuficiencia
llama a los métodos añadirán tal método falla @Transactional la queryUser

@Service
public class UserServiceImpl  {
    @Transactional
    public String queryUser(String userId) {
        System.out.println("UserServiceImpl1 ->" + userId);
        return "UserServiceImpl1 ->" + userId;
    }
    @Transactional
    public void add(String id) {
        queryUser(id);
        System.out.println("UserServiceImpl1 -> addxx");
    }
}

AOP de resorte es una parte importante de la primavera, la primavera implementar por el proxy dinámico, proceso objeto instanciación del resorte tendrá una sección de modo que un objeto es un proxy dinámico de acuerdo con un ejemplo, el proceso específico es mayor en la requerida haba dinámico instanciación del agente después de la finalización, applyBeanPostProcessorsAfterInitialization específica AbstractAutowireCapableBeanFactory la entrada ()

Este método atravesar todo el interfaz BeanPostProcessor dado cuenta

El método llama así a AspectJwareAdvisorAutoProxyCreator clase postProcessBeforeInstantiation (AbstractAutoProxyCreator)
, Este método llama a wrapIfNecessary () llamará a la getAdvicesAndAdvisorsForBean (), que es principalmente encapsular toda la sección objetos, y la sección de juego y juego de clase luego regresó,
entonces en wrapIfNecessary crear () en el objeto proxy, las llamadas específicas a createProxy (), el método crea primero una fábrica de proxy, nota que esta planta es un multi-real, un beanClass correspondiente a una fábrica de proxy, la fábrica de proxy encapsula el objeto proxy y este es el objeto proxy en todos los aspectos (el enfoque de este plan, la fábrica es la presencia del objeto agente proxy !!!!), y luego crear un objeto proxy a través de una fábrica de proxy.

En este momento, la primavera se configurará de acuerdo con la configuración es JdkDynamicAopProxy (dinámico proxy de JDK) o ObjenesisCglibAopProxy (agente cglib) generado, no importa qué tipo de agente tendrá dos tipos de objetos encapsulados en la fábrica, a jdkDynamicAopProxy ejemplo: llamada de método getProxy , devolverá un objeto proxy. Cuando se llama a un objeto proxy de vuelta y vuelta invoke () de JdkDynamicAopProxy transferido.

Mirada en el foco invocar métodos: método de invocación mirada de cierre principal en el método, el primer método es determinar si hay un corte, y la forma de llamar a la sección de métodos, Primavera utiliza un modelo de cadena de filtros, sólo hay que poner el paquete a la fábrica de proxy objeto jdkDynamicAopProxy, y todos podemos conseguir a través del objeto a cortar todo el objeto proxy, y después se cumplan estas con la sección de métodos, que coincide con el éxito de la sección de la primavera será cortado en el paquete de mejoras en el tipo MethodInterceptor del objeto, ¿por qué debería empaquetar MethodIntercepor se opone a ella, debido principalmente al aumento existen cinco especies, si no se empaquetan en un tipo unificado de objeto, entonces habrá una gran cantidad de juez si-else. Al finalizar () Este método getInterceptorsAndDynamicInterceptionAdvice el proceso anterior, principalmente en AdvisedSupport esta clase, que se encuentra la cadena de llamada será llamado. invoke () método será un objeto de tipo ReflectiveMethodInvocation parámetros del método audiencias objetivo audiencias encapsulado, el tipo de llamada proceder método (), el método será de nuevo en la forma de una cadena de llamadas que llegan a método de corte determina si llevar a cabo completa , si se ha completado la ejecución será llamado por el método de reflexión para orientar el objeto de destino y el aviso de que el objeto de destino es un objeto proxy! ! !

Al leer el código fuente de springAOP, sabemos por qué el mismo enfoque, estamos en un método para llamar a otro método hace que otro método anotado fracaso. . . El propio autor ha escrito el código fuente se producirá en la primavera de proxy dinámico intentos clase salida a un archivo sobre:

yo

mport com.sun.proxy..Proxy50;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
import java.lang.reflect.UndeclaredThrowableException;
import org.aopalliance.aop.Advice;
import org.springframework.aop.Advisor;
import org.springframework.aop.TargetSource;
import org.springframework.aop.framework.AopConfigException;

public final class userServiceProxy extends Proxy implements Proxy50 {
    private static Method m1;
    private static Method m31;
    private static Method m19;
    private static Method m24;
    private static Method m18;
    private static Method m14;
    private static Method m26;
    private static Method m32;
    private static Method m3;
    private static Method m21;
    private static Method m7;
    private static Method m6;
    private static Method m0;
    private static Method m28;
    private static Method m16;
    private static Method m23;
    private static Method m30;
    private static Method m34;
    private static Method m11;
    private static Method m2;
    private static Method m10;
    private static Method m12;
    private static Method m20;
    private static Method m13;
    private static Method m4;
    private static Method m5;
    private static Method m36;
    private static Method m9;
    private static Method m17;
    private static Method m38;
    private static Method m22;
    private static Method m33;
    private static Method m8;
    private static Method m37;
    private static Method m35;
    private static Method m27;
    private static Method m29;
    private static Method m25;
    private static Method m15;

    public userServiceProxy(InvocationHandler var1) throws  {
        super(var1);
    }

    public final boolean equals(Object var1) throws  {
        try {
            return (Boolean)super.h.invoke(this, m1, new Object[]{var1});
        } catch (RuntimeException | Error var3) {
            throw var3;
        } catch (Throwable var4) {
            throw new UndeclaredThrowableException(var4);
        }
    }

    public final InvocationHandler getInvocationHandler(Object var1) throws IllegalArgumentException {
        try {
            return (InvocationHandler)super.h.invoke(this, m31, new Object[]{var1});
        } catch (RuntimeException | Error var3) {
            throw var3;
        } catch (Throwable var4) {
            throw new UndeclaredThrowableException(var4);
        }
    }

    public final void addAdvisor(Advisor var1) throws AopConfigException {
        try {
            super.h.invoke(this, m19, new Object[]{var1});
        } catch (RuntimeException | Error var3) {
            throw var3;
        } catch (Throwable var4) {
            throw new UndeclaredThrowableException(var4);
        }
    }

    public final boolean isExposeProxy() throws  {
        try {
            return (Boolean)super.h.invoke(this, m24, (Object[])null);
        } catch (RuntimeException | Error var2) {
            throw var2;
        } catch (Throwable var3) {
            throw new UndeclaredThrowableException(var3);
        }
    }

    public final boolean isProxyTargetClass() throws  {
        try {
            return (Boolean)super.h.invoke(this, m18, (Object[])null);
        } catch (RuntimeException | Error var2) {
            throw var2;
        } catch (Throwable var3) {
            throw new UndeclaredThrowableException(var3);
        }
    }

    public final void removeAdvisor(int var1) throws AopConfigException {
        try {
            super.h.invoke(this, m14, new Object[]{var1});
        } catch (RuntimeException | Error var3) {
            throw var3;
        } catch (Throwable var4) {
            throw new UndeclaredThrowableException(var4);
        }
    }

    public final Class[] getProxiedInterfaces() throws  {
        try {
            return (Class[])super.h.invoke(this, m26, (Object[])null);
        } catch (RuntimeException | Error var2) {
            throw var2;
        } catch (Throwable var3) {
            throw new UndeclaredThrowableException(var3);
        }
    }

    public final Class getProxyClass(ClassLoader var1, Class[] var2) throws IllegalArgumentException {
        try {
            return (Class)super.h.invoke(this, m32, new Object[]{var1, var2});
        } catch (RuntimeException | Error var4) {
            throw var4;
        } catch (Throwable var5) {
            throw new UndeclaredThrowableException(var5);
        }
    }

    public final int indexOf(Advisor var1) throws  {
        try {
            return (Integer)super.h.invoke(this, m3, new Object[]{var1});
        } catch (RuntimeException | Error var3) {
            throw var3;
        } catch (Throwable var4) {
            throw new UndeclaredThrowableException(var4);
        }
    }

    public final TargetSource getTargetSource() throws  {
        try {
            return (TargetSource)super.h.invoke(this, m21, (Object[])null);
        } catch (RuntimeException | Error var2) {
            throw var2;
        } catch (Throwable var3) {
            throw new UndeclaredThrowableException(var3);
        }
    }

    public final void addAdvice(int var1, Advice var2) throws AopConfigException {
        try {
            super.h.invoke(this, m7, new Object[]{var1, var2});
        } catch (RuntimeException | Error var4) {
            throw var4;
        } catch (Throwable var5) {
            throw new UndeclaredThrowableException(var5);
        }
    }

    public final void addAdvice(Advice var1) throws AopConfigException {
        try {
            super.h.invoke(this, m6, new Object[]{var1});
        } catch (RuntimeException | Error var3) {
            throw var3;
        } catch (Throwable var4) {
            throw new UndeclaredThrowableException(var4);
        }
    }

    public final int hashCode() throws  {
        try {
            return (Integer)super.h.invoke(this, m0, (Object[])null);
        } catch (RuntimeException | Error var2) {
            throw var2;
        } catch (Throwable var3) {
            throw new UndeclaredThrowableException(var3);
        }
    }

    public final boolean isInterfaceProxied(Class var1) throws  {
        try {
            return (Boolean)super.h.invoke(this, m28, new Object[]{var1});
        } catch (RuntimeException | Error var3) {
            throw var3;
        } catch (Throwable var4) {
            throw new UndeclaredThrowableException(var4);
        }
    }

    public final boolean removeAdvice(Advice var1) throws  {
        try {
            return (Boolean)super.h.invoke(this, m16, new Object[]{var1});
        } catch (RuntimeException | Error var3) {
            throw var3;
        } catch (Throwable var4) {
            throw new UndeclaredThrowableException(var4);
        }
    }

    public final void setExposeProxy(boolean var1) throws  {
        try {
            super.h.invoke(this, m23, new Object[]{var1});
        } catch (RuntimeException | Error var3) {
            throw var3;
        } catch (Throwable var4) {
            throw new UndeclaredThrowableException(var4);
        }
    }

    public final Object newProxyInstance(ClassLoader var1, Class[] var2, InvocationHandler var3) throws IllegalArgumentException {
        try {
            return (Object)super.h.invoke(this, m30, new Object[]{var1, var2, var3});
        } catch (RuntimeException | Error var5) {
            throw var5;
        } catch (Throwable var6) {
            throw new UndeclaredThrowableException(var6);
        }
    }

    public final void wait(long var1, int var3) throws InterruptedException {
        try {
            super.h.invoke(this, m34, new Object[]{var1, var3});
        } catch (RuntimeException | InterruptedException | Error var5) {
            throw var5;
        } catch (Throwable var6) {
            throw new UndeclaredThrowableException(var6);
        }
    }

    public final void setTargetSource(TargetSource var1) throws  {
        try {
            super.h.invoke(this, m11, new Object[]{var1});
        } catch (RuntimeException | Error var3) {
            throw var3;
        } catch (Throwable var4) {
            throw new UndeclaredThrowableException(var4);
        }
    }

    public final String toString() throws  {
        try {
            return (String)super.h.invoke(this, m2, (Object[])null);
        } catch (RuntimeException | Error var2) {
            throw var2;
        } catch (Throwable var3) {
            throw new UndeclaredThrowableException(var3);
        }
    }

    public final Class getTargetClass() throws  {
        try {
            return (Class)super.h.invoke(this, m10, (Object[])null);
        } catch (RuntimeException | Error var2) {
            throw var2;
        } catch (Throwable var3) {
            throw new UndeclaredThrowableException(var3);
        }
    }

    public final Class getDecoratedClass() throws  {
        try {
            return (Class)super.h.invoke(this, m12, (Object[])null);
        } catch (RuntimeException | Error var2) {
            throw var2;
        } catch (Throwable var3) {
            throw new UndeclaredThrowableException(var3);
        }
    }

    public final void addAdvisor(int var1, Advisor var2) throws AopConfigException {
        try {
            super.h.invoke(this, m20, new Object[]{var1, var2});
        } catch (RuntimeException | Error var4) {
            throw var4;
        } catch (Throwable var5) {
            throw new UndeclaredThrowableException(var5);
        }
    }

    public final boolean removeAdvisor(Advisor var1) throws  {
        try {
            return (Boolean)super.h.invoke(this, m13, new Object[]{var1});
        } catch (RuntimeException | Error var3) {
            throw var3;
        } catch (Throwable var4) {
            throw new UndeclaredThrowableException(var4);
        }
    }

    public final int indexOf(Advice var1) throws  {
        try {
            return (Integer)super.h.invoke(this, m4, new Object[]{var1});
        } catch (RuntimeException | Error var3) {
            throw var3;
        } catch (Throwable var4) {
            throw new UndeclaredThrowableException(var4);
        }
    }

    public final boolean isFrozen() throws  {
        try {
            return (Boolean)super.h.invoke(this, m5, (Object[])null);
        } catch (RuntimeException | Error var2) {
            throw var2;
        } catch (Throwable var3) {
            throw new UndeclaredThrowableException(var3);
        }
    }

    public final Class getClass() throws  {
        try {
            return (Class)super.h.invoke(this, m36, (Object[])null);
        } catch (RuntimeException | Error var2) {
            throw var2;
        } catch (Throwable var3) {
            throw new UndeclaredThrowableException(var3);
        }
    }

    public final void addxx(String var1) throws  {
        try {
            super.h.invoke(this, m9, new Object[]{var1});
        } catch (RuntimeException | Error var3) {
            throw var3;
        } catch (Throwable var4) {
            throw new UndeclaredThrowableException(var4);
        }
    }

    public final boolean replaceAdvisor(Advisor var1, Advisor var2) throws AopConfigException {
        try {
            return (Boolean)super.h.invoke(this, m17, new Object[]{var1, var2});
        } catch (RuntimeException | Error var4) {
            throw var4;
        } catch (Throwable var5) {
            throw new UndeclaredThrowableException(var5);
        }
    }

    public final void notifyAll() throws  {
        try {
            super.h.invoke(this, m38, (Object[])null);
        } catch (RuntimeException | Error var2) {
            throw var2;
        } catch (Throwable var3) {
            throw new UndeclaredThrowableException(var3);
        }
    }

    public final void setPreFiltered(boolean var1) throws  {
        try {
            super.h.invoke(this, m22, new Object[]{var1});
        } catch (RuntimeException | Error var3) {
            throw var3;
        } catch (Throwable var4) {
            throw new UndeclaredThrowableException(var4);
        }
    }

    public final void wait() throws InterruptedException {
        try {
            super.h.invoke(this, m33, (Object[])null);
        } catch (RuntimeException | InterruptedException | Error var2) {
            throw var2;
        } catch (Throwable var3) {
            throw new UndeclaredThrowableException(var3);
        }
    }

    public final String queryUser(String var1) throws  {
        try {
            return (String)super.h.invoke(this, m8, new Object[]{var1});
        } catch (RuntimeException | Error var3) {
            throw var3;
        } catch (Throwable var4) {
            throw new UndeclaredThrowableException(var4);
        }
    }

    public final void notify() throws  {
        try {
            super.h.invoke(this, m37, (Object[])null);
        } catch (RuntimeException | Error var2) {
            throw var2;
        } catch (Throwable var3) {
            throw new UndeclaredThrowableException(var3);
        }
    }

    public final void wait(long var1) throws InterruptedException {
        try {
            super.h.invoke(this, m35, new Object[]{var1});
        } catch (RuntimeException | InterruptedException | Error var4) {
            throw var4;
        } catch (Throwable var5) {
            throw new UndeclaredThrowableException(var5);
        }
    }

    public final String toProxyConfigString() throws  {
        try {
            return (String)super.h.invoke(this, m27, (Object[])null);
        } catch (RuntimeException | Error var2) {
            throw var2;
        } catch (Throwable var3) {
            throw new UndeclaredThrowableException(var3);
        }
    }

    public final boolean isProxyClass(Class var1) throws  {
        try {
            return (Boolean)super.h.invoke(this, m29, new Object[]{var1});
        } catch (RuntimeException | Error var3) {
            throw var3;
        } catch (Throwable var4) {
            throw new UndeclaredThrowableException(var4);
        }
    }

    public final Advisor[] getAdvisors() throws  {
        try {
            return (Advisor[])super.h.invoke(this, m25, (Object[])null);
        } catch (RuntimeException | Error var2) {
            throw var2;
        } catch (Throwable var3) {
            throw new UndeclaredThrowableException(var3);
        }
    }

    public final boolean isPreFiltered() throws  {
        try {
            return (Boolean)super.h.invoke(this, m15, (Object[])null);
        } catch (RuntimeException | Error var2) {
            throw var2;
        } catch (Throwable var3) {
            throw new UndeclaredThrowableException(var3);
        }
    }

    static {
        try {
            m1 = Class.forName("java.lang.Object").getMethod("equals", Class.forName("java.lang.Object"));
            m31 = Class.forName("com.sun.proxy.$Proxy50").getMethod("getInvocationHandler", Class.forName("java.lang.Object"));
            m19 = Class.forName("com.sun.proxy.$Proxy50").getMethod("addAdvisor", Class.forName("org.springframework.aop.Advisor"));
            m24 = Class.forName("com.sun.proxy.$Proxy50").getMethod("isExposeProxy");
            m18 = Class.forName("com.sun.proxy.$Proxy50").getMethod("isProxyTargetClass");
            m14 = Class.forName("com.sun.proxy.$Proxy50").getMethod("removeAdvisor", Integer.TYPE);
            m26 = Class.forName("com.sun.proxy.$Proxy50").getMethod("getProxiedInterfaces");
            m32 = Class.forName("com.sun.proxy.$Proxy50").getMethod("getProxyClass", Class.forName("java.lang.ClassLoader"), Class.forName("[Ljava.lang.Class;"));
            m3 = Class.forName("com.sun.proxy.$Proxy50").getMethod("indexOf", Class.forName("org.springframework.aop.Advisor"));
            m21 = Class.forName("com.sun.proxy.$Proxy50").getMethod("getTargetSource");
            m7 = Class.forName("com.sun.proxy.$Proxy50").getMethod("addAdvice", Integer.TYPE, Class.forName("org.aopalliance.aop.Advice"));
            m6 = Class.forName("com.sun.proxy.$Proxy50").getMethod("addAdvice", Class.forName("org.aopalliance.aop.Advice"));
            m0 = Class.forName("java.lang.Object").getMethod("hashCode");
            m28 = Class.forName("com.sun.proxy.$Proxy50").getMethod("isInterfaceProxied", Class.forName("java.lang.Class"));
            m16 = Class.forName("com.sun.proxy.$Proxy50").getMethod("removeAdvice", Class.forName("org.aopalliance.aop.Advice"));
            m23 = Class.forName("com.sun.proxy.$Proxy50").getMethod("setExposeProxy", Boolean.TYPE);
            m30 = Class.forName("com.sun.proxy.$Proxy50").getMethod("newProxyInstance", Class.forName("java.lang.ClassLoader"), Class.forName("[Ljava.lang.Class;"), Class.forName("java.lang.reflect.InvocationHandler"));
            m34 = Class.forName("com.sun.proxy.$Proxy50").getMethod("wait", Long.TYPE, Integer.TYPE);
            m11 = Class.forName("com.sun.proxy.$Proxy50").getMethod("setTargetSource", Class.forName("org.springframework.aop.TargetSource"));
            m2 = Class.forName("java.lang.Object").getMethod("toString");
            m10 = Class.forName("com.sun.proxy.$Proxy50").getMethod("getTargetClass");
            m12 = Class.forName("com.sun.proxy.$Proxy50").getMethod("getDecoratedClass");
            m20 = Class.forName("com.sun.proxy.$Proxy50").getMethod("addAdvisor", Integer.TYPE, Class.forName("org.springframework.aop.Advisor"));
            m13 = Class.forName("com.sun.proxy.$Proxy50").getMethod("removeAdvisor", Class.forName("org.springframework.aop.Advisor"));
            m4 = Class.forName("com.sun.proxy.$Proxy50").getMethod("indexOf", Class.forName("org.aopalliance.aop.Advice"));
            m5 = Class.forName("com.sun.proxy.$Proxy50").getMethod("isFrozen");
            m36 = Class.forName("com.sun.proxy.$Proxy50").getMethod("getClass");
            m9 = Class.forName("com.sun.proxy.$Proxy50").getMethod("addxx", Class.forName("java.lang.String"));
            m17 = Class.forName("com.sun.proxy.$Proxy50").getMethod("replaceAdvisor", Class.forName("org.springframework.aop.Advisor"), Class.forName("org.springframework.aop.Advisor"));
            m38 = Class.forName("com.sun.proxy.$Proxy50").getMethod("notifyAll");
            m22 = Class.forName("com.sun.proxy.$Proxy50").getMethod("setPreFiltered", Boolean.TYPE);
            m33 = Class.forName("com.sun.proxy.$Proxy50").getMethod("wait");
            m8 = Class.forName("com.sun.proxy.$Proxy50").getMethod("queryUser", Class.forName("java.lang.String"));
            m37 = Class.forName("com.sun.proxy.$Proxy50").getMethod("notify");
            m35 = Class.forName("com.sun.proxy.$Proxy50").getMethod("wait", Long.TYPE);
            m27 = Class.forName("com.sun.proxy.$Proxy50").getMethod("toProxyConfigString");
            m29 = Class.forName("com.sun.proxy.$Proxy50").getMethod("isProxyClass", Class.forName("java.lang.Class"));
            m25 = Class.forName("com.sun.proxy.$Proxy50").getMethod("getAdvisors");
            m15 = Class.forName("com.sun.proxy.$Proxy50").getMethod("isPreFiltered");
        } catch (NoSuchMethodException var2) {
            throw new NoSuchMethodError(var2.getMessage());
        } catch (ClassNotFoundException var3) {
            throw new NoClassDefFoundError(var3.getMessage());
        }
    }
}

De hecho, se puede ver la producción de llamada a un método de clase proxy dinámico es la última llamada al método h.invoke (), es decir, antes de la h objetos de tipo JdkDynamicAopProxy, h.invoke es llamar a la parte delantera que llamamos el método de invocación, que llamamos directamente el método la mejora es, en efecto, pero otros métodos de esta clase para llamar directamente en el proceso de mejora no es eficaz, porque vamos a llamar para invocar el método retVal = invocatin.proceed (), y el método de la final se llama a través del objeto proxy para llamar a sus propios métodos y, finalmente, realizar method.invke (objetivo, args) este código, así que llamamos a dirigirse directamente a otro método de esta clase, dará lugar a la insuficiencia de las anotaciones. En conclusión, es porque usamos el uso final original, para llamar al objeto más que el objeto proxy a la llamada, lo que resulta en un fracaso mejorada. La solución es sencilla, reemplazamos el objeto proxy para llamarlo.