seata1.0 lograr la degradación de fingir y de gestión de excepciones global cuando la transacción se retrotrae

fuente descarga

Puede dirigir micro-canal de lectura de códigos de dos dimensiones por encima de mi número de la preocupación del público, que le responderán excepción de SEAT a la dirección de descarga de código fuente también se adherirá tutoriales de vídeo correspondiente, y regularmente compartir artículos técnicos pertinentes con usted.

prefacio

En el proceso de nuestro desarrollo, si se produce una excepción, vamos a llevar a cabo intento normales ... catch o configure una excepción mundial de relleno pueden procesar, o fingir nuestros puntos de degradación del servicio, si esta vez utilizamos las transacciones distribuidas de SEAT a continuación, vamos a encontrar que nos la operación no se puede deshacer, no utilice nuestras transacciones distribuidas que no podemos hacer gestión de excepciones todavía? Obviamente, esto no es posible, a través del programa oficial del dios de forma dinámica creada por la AOP cerca de transacción / de SEAT distribuido encontramos una solución que funciona en nuestra parte del artículo se basa en la versión basada en la nube Greenwich.SR2 seata1.0 y la primavera de realización de demostración ejemplos de transacciones distribuidas todo el proceso de transformación sobre la base de este artículo.

Configuración rebaja fingir

Ya que sólo hay que verificar que una rebaja de servicio, por lo que esta vez vamos a probar directamente nuestra cuenta de módulo de orden de la degradación del servicio, si el servicio a la degradación fingir no entienden se puede ver directamente en este blog [primavera nube de Hoxton. lograr degradación elegante de la versión SR1 Feign], (https://linzhefeng23.blog.csdn.net/article/details/103710038) creamos un paquete impl directamente debajo Feign fin-servidor, así como crear un AccountApiImpl lograr AccountApi , como sigue:

/**
 * @author linzf
 * @since 2019/12/27
 * 类描述：
 */
@Component
public class AccountApiImpl implements AccountApi {


    @Override
    public String decrease(Long userId, BigDecimal money) {
        System.out.println("我被服务降级了，回滚了吗？");
        return "我被服务降级了！";
    }
}

Luego modificamos nuestra AccountApi añadió más tarde nuestra repliegue modificar el código de la siguiente manera:

@FeignClient(value = "account-server",fallback = AccountApiImpl.class)
public interface AccountApi {

    /**
     * 扣减账户余额
     * @param userId 用户id
     * @param money 金额
     * @return
     */
    @RequestMapping("/account/decrease")
    String decrease(@RequestParam("userId") Long userId, @RequestParam("money") BigDecimal money);
}

Por último, hemos modificado nuestros AccountServiceImpl módulo cuenta en servidor disminuyen el método implementado llamadas a métodos de simulación excepción de error directamente hacia atrás el proceso, el código subsiguiente de la siguiente manera:

@Service("accountServiceImpl")
public class AccountServiceImpl implements AccountService{

    private static final Logger LOGGER = LoggerFactory.getLogger(AccountServiceImpl.class);
    @Autowired
    private AccountDao accountDao;
    @Autowired
    private OrderApi orderApi;

    /**
     * 扣减账户余额
     * @param userId 用户id
     * @param money 金额
     */
    @Override
    public void decrease(Long userId, BigDecimal money) {
        LOGGER.info("------->扣减账户开始account中");
        //模拟超时异常，全局事务回滚
//        try {
//            Thread.sleep(30*1000);
//        } catch (InterruptedException e) {
//            e.printStackTrace();
//        }
        accountDao.decrease(userId,money);
        LOGGER.info("------->扣减账户结束account中");

        //修改订单状态，此调用会导致调用成环
        LOGGER.info("修改订单状态开始");
        String mes = orderApi.update(userId, money.multiply(new BigDecimal("0.09")),0);
        LOGGER.info("修改订单状态结束：{}",mes);
        throw new RuntimeException("我出错了，会被回滚吗？");
    }
}

Por último, hay que modificar el archivo de configuración de las propiedades application.yml feign.hystrix.enabled de orden-servidor se establece en el valor verdadero, y finalmente empezar nuestro de SEAT-servidor, registro, cuenta-servidor, para-servidor , el almacenamiento en servidor, después de comenzar nuestra acceso directo a la siguiente dirección: http: // localhost: 8180 / pedido / crear ID de usuario = 1 & productId = 1 & count = 10 y dinero = 100, esta vez nos encontramos el gatillo para un servidor una transacción rebaja de la siguiente manera? :

luego encontramos que no deshacer la transacción, pero se ejecuta correctamente, y que esto no es claramente el resultado que queremos, cómo hacerlo en esta ocasión, nos referimos directamente a nuestro gran Dios al programa oficial dinámicamente creado por AOP de encendido / apagado de SEAT distribuye transacción para resolver el problema de nuestras operaciones no se deshace.

Lograr la degradación fingir cuando la transacción se retrotrae

Directamente en nuestra cuenta en el servidor, para el servidor, el almacenamiento en servidores bajo el proyecto para crear un directorio de configuración y, a continuación, crear nuestra categoría de la sección de procesamiento de transacciones [WorkAspect] código es el siguiente:

/**
 * @author linzf
 * @since 2019/12/27
 * 类描述： 用于处理程序调用发生异常的时候由于异常被处理以后无法触发事务，而进行的处理，使之可以正常的触发事务。
 */
@Aspect
@Component
public class WorkAspect {

    private final static Logger logger = LoggerFactory.getLogger(WorkAspect.class);

    @Before("execution(* io.seata.sample.service.*.*(..))")
    public void before(JoinPoint joinPoint) throws TransactionException {
        MethodSignature signature = (MethodSignature)joinPoint.getSignature();
        Method method = signature.getMethod();
        logger.info("拦截到需要分布式事务的方法," + method.getName());
        // 此处可用redis或者定时任务来获取一个key判断是否需要关闭分布式事务
        GlobalTransaction tx = GlobalTransactionContext.getCurrentOrCreate();
        tx.begin(300000, "test-client");
        logger.info("创建分布式事务完毕" + tx.getXid());
    }

    @AfterThrowing(throwing = "e", pointcut = "execution(* io.seata.sample.service.*.*(..))")
    public void doRecoveryActions(Throwable e) throws TransactionException {
        logger.info("方法执行异常:{}", e.getMessage());
        if (!StringUtils.isBlank(RootContext.getXID())) {
            GlobalTransactionContext.reload(RootContext.getXID()).rollback();
        }
    }

}

En este momento al servicio de nuestro método de cuenta de servidor de [excepciones de tiempo de espera simulados, la reversión de transacción global] este comentario a dejar ir, el acceso y luego directo a: http: // localhost: 8180 / pedido / Crear ID de usuario = 1 & productId = 1 & contar? = 10 = 100 y dinero, y luego encontramos nuestro negocio para lograr una reversión, que logran el efecto que queremos.

Después de la realización de la gestión de excepciones de la transacción global rollback

Hemos configurado un [dirigir] GlobalExceptionsHandler en nuestra cuenta en el servidor bajo el siguiente código:

/**
 * @author linzf
 * @since 2019/5/29
 * 类描述：全局异常捕获处理
 */
@ControllerAdvice
public class GlobalExceptionsHandler {

    private Logger log = LoggerFactory.getLogger(GlobalExceptionsHandler.class);

    /**
     * 功能描述：全局异常处理
     *
     * @param e
     * @return 返回处理结果
     * @throws Exception
     */
    @ExceptionHandler(value = Exception.class)
    @ResponseBody
    public Object errorHandler(Exception e) throws Exception {
        // 此处为属性级的错误日志的处理
        if (e instanceof ConstraintViolationException) {
            log.info("绑定错误日志为：{}", e.getMessage());
            return "请求数据格式错误";
            // 此处为方法级别的错误日志处理
        } else if (e instanceof MethodArgumentNotValidException) {
            log.info("方法级的绑定错误日志为：{}", e.getMessage());
            return "请求数据格式错误";
            // 此处为全局错误日志的处理
        } else {
            log.info("错误日志为：{}", e.getMessage());
            return "全局异常错误给捕获了！";
        }
    }


}

Esta vez tenemos que lanzar una carrera en el método de servicio de cuenta-servidor cuando anormal, entonces tenemos acceso directo a: http: // localhost: 8180 / pedido / crear ID de usuario = 1 & productId = 1 & count = 10 y dinero = 100, y luego nos damos cuenta de que? deshacer la transacción realizada, con ello se consigue el efecto que queremos.