marco de primavera-AOP

1. Concepto AOP de marco de resorte

Un componente clave del marco Spring es el marco de programación orientada a aspectos (AOP). La programación orientada a aspectos necesita descomponer la lógica del programa en diferentes partes denominadas preocupaciones. Las funciones que abarcan varios puntos de una aplicación se denominan preocupaciones transversales y estas preocupaciones transversales son conceptualmente independientes de la lógica empresarial de la aplicación.

Este concepto puede ser muy abstracto, pero solo necesita saber que AOP es equivalente a un interceptor utilizado para interceptar métodos o programas.Puede agregar funciones adicionales antes o después de que se ejecute el método.

Dos, términos relacionados con AOP

Tipos de notificaciones de términos relacionados (tipos de corte)

1. Notificación previa <aop: before> </ aop: before>: realiza una notificación antes de que se ejecute un método.
2. Publicar notificación <aop: after> </ aop: after>: después de que se ejecuta un método, la notificación se ejecuta independientemente del resultado.
3. Notificación después de la devolución <aop: after-return> </ aop: after-return>: Después de que se ejecuta un método, la notificación solo se puede ejecutar cuando el método se completa correctamente.
4. Notificación después de que se lanza una excepción <aop: after-throwing> </ aop: after-throwing>: después de que se ejecuta un método, la notificación solo se puede ejecutar cuando el método sale y lanza una excepción
5. Alrededor de la notificación <aop: around> </ aop: round>: Realice una notificación antes y después de que se llame al método de sugerencia.

3. Ejemplos (depósito y depósito)

1. Catálogo de categorías relacionadas

2. BankDao (Check y EmpDao son opcionales)

package sc.dao;

public interface BankDao {
    
    
    //转账
    public void remirt();
    //存钱
    public void save();
}

3 、 AdminCheck

package sc.impl;

import sc.dao.Check;

public class AdminCheck implements Check{
    
    
    public void check(){
    
    
        System.out.println("权限验证开始");
    }
}

4. BankDaoImpl (no se requiere EmpDaoImpl)

package sc.impl;

import sc.dao.BankDao;

public class BankDaoImpl implements BankDao{
    
    
    @Override
    public void remirt() {
    
    
        System.out.println("转账的业务");
    }

    @Override
    public void save() {
    
    
        System.out.println("存钱的业务");
    }
}

5 、 logManager

package sc.impl;

public class LogManager {
    
    
    public void writelog(){
    
    
        System.out.println("日志正在写入");
    }
}

6 、 TransactionManager

package sc.impl;

public class TransactionManager {
    
    
    public void begin(){
    
    
        System.out.println("开始业务逻辑");
    }
    public void commit(){
    
    
        System.out.println("提交业务逻辑");
    }

}

7 、 primavera.xml

<?xml version="1.0" encoding="UTF-8"?>
<beans
        xmlns="http://www.springframework.org/schema/beans"
        xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
        xmlns:context="http://www.springframework.org/schema/context"
        xmlns:aop="http://www.springframework.org/schema/aop"
        xsi:schemaLocation="http://www.springframework.org/schema/beans
        http://www.springframework.org/schema/beans/spring-beans-4.3.xsd
        http://www.springframework.org/schema/context
        http://www.springframework.org/schema/context/spring-context-4.3.xsd
        http://www.springframework.org/schema/aop
        http://www.springframework.org/schema/aop/spring-aop-4.3.xsd
">
    <bean id="adminCheck" class="sc.impl.AdminCheck"></bean>
    <bean id="transactionManager" class="sc.impl.TransactionManager"></bean>
    <bean id="logManager" class="sc.impl.LogManager"></bean>
    <bean id="bankDao" class="sc.impl.BankDaoImpl"></bean>
    <bean id="empDao" class="sc.impl.EmpDaoImpl"></bean>

    <!--开始spring aop 面向切面-->
    <aop:config>
        <!--切入点-->
        <aop:pointcut id="service" expression="execution(* sc.impl.*.*(..))"></aop:pointcut>

        <aop:aspect ref="adminCheck">
            <!--在此之前切入-->
            <aop:before method="check" pointcut-ref="service"></aop:before>
        </aop:aspect>

        <aop:aspect ref="transactionManager">
            <aop:before method="begin" pointcut-ref="service"></aop:before>
        </aop:aspect>


        <!--after method 用于那个方法是最终通知  谁在最前面  最后输出就在最后 -->
        <aop:aspect ref="logManager">
            <aop:after method="writelog" pointcut-ref="service"></aop:after>
        </aop:aspect>

        <aop:aspect ref="transactionManager">
            <aop:after method="commit" pointcut-ref="service"></aop:after>
        </aop:aspect>


    </aop:config>

</beans>

8 、 prueba

package sc.test;

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import sc.dao.BankDao;
import sc.dao.Check;

public class Test {
    
    
    public static void main(String[] args) {
    
    
        ApplicationContext ac = new ClassPathXmlApplicationContext("spring.xml");

        BankDao bankDao = (BankDao) ac.getBean("bankDao");
        bankDao.remirt();
        System.out.println("----------------------");
        bankDao.save();
    }
}

El resultado de la operación es
que esto puede reducir la redundancia del código. Encontrará que el inicio de la verificación, el inicio de la lógica empresarial, el envío de la lógica empresarial y el registro se escriben solo una vez, pero puede ser utilizado dos veces.