2021-10-19数据库事务transaction，基于手动AOP实现

 事务：是指逻辑上的一组操作，组成这组操作的各个单元，要么全部成功，要么全部不成功。

service层处理业务， 

• 原子性：指事务是一个不可分割的工作单位，事务中的操作要么都发生，要么都不发生。
• 一致性：事务必须使数据库从一个一致性状态变换到另外一个一致性状态。
• 隔离性：事务的隔离性是指多个用户并发访问数据库时，数据库为每一个用户开启的事务，不能被其他事务的操作数据所干扰，多个并发事务之间要相互隔离。
• 持久性：指一个事务一旦被提交，它对数据库中的数据的改变就是永久性的，接下来即使数据库发生故障也不应该对其有任务影响。

手动开启事务

begin；开启

rollback；事务回滚

commit；提交，未提交会一直挂在数据库内存

两人之间转账1000元；银行柜员5点半下班 统计数据；公交车分别坐着1，2，位置，为3号占座位。

• read uncommitted 读未提交。脏读，不可重复读，虚读都有可能发生
• read committed 读已提交。避免脏读，不可重复读，虚读都有可能发生（oracle默认）
• repeatable read 可重复读 。避免脏读和不可重复读，虚读可能发生。（mysql默认）
• serializable序列化。避免脏读和不可重重复读，虚读（已持久化，依然无法读到）。

 

package com.asjy.service.controller;

import com.asjy.service.UserService;
import com.asjy.service.util.ProxyFactroy;
import org.junit.Test;

public class UserController {
    @Test
    public void fun4(){
        //UserService proxyImpl = ProxyFactroy.getProxyImpl();
        UserService proxyImpl = ProxyFactroy.getProxyByCgLib();
        proxyImpl.addUser();
    }
}

package com.asjy.service;

public interface UserService {
    void addUser();
}

package com.asjy.service.impl;

import com.asjy.service.UserService;

public class UserServiceImpl implements UserService {
    public void addUser(){
        System.out.println("添加成功！");
    }
}


package com.asjy.service.util;

public class MyAspect {
    public void begin(){
        System.out.println("开启事务");
    }
    public void commit(){
        System.out.println("关闭事务");
    }
}


package com.asjy.service.util;

import com.asjy.service.UserService;
import com.asjy.service.impl.UserServiceImpl;
import org.springframework.cglib.proxy.Enhancer;
import org.springframework.cglib.proxy.MethodInterceptor;
import org.springframework.cglib.proxy.MethodProxy;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
//基于接口的动态代理
public class ProxyFactroy {
    public static UserService getProxyImpl(){
        //被代理对象
        UserService userService=new UserServiceImpl();
        MyAspect myAspect = new MyAspect();
        //生产代理对象
        /*
        * 指定被代理类的类加载器
        *指定被代理类的接口
        * 指定代理方法的策略
        * */
        UserService proxyUserService = (UserService) Proxy.newProxyInstance(userService.getClass().getClassLoader(), userService.getClass().getInterfaces(), new InvocationHandler() {
            /*
             * 代理对象的引用
             * 代理对象的方法
             * 代理对象方法的参数
             * */
            @Override
            public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                myAspect.begin();
                Object invoke = method.invoke(userService);
                myAspect.commit();
                return invoke;
            }
        });
        return proxyUserService;
    }

    //基于继承的动态代理 cglib
    public static UserService getProxyByCgLib(){
        //指明代理类和切面类
        UserService userService = new UserServiceImpl();
        MyAspect myAspect = new MyAspect();
        Enhancer enhancer=new Enhancer();
        enhancer.setSuperclass(userService.getClass());
        enhancer.setCallback(new MethodInterceptor() {
            @Override
            public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {
                myAspect.begin();
                Object invoke = method.invoke(userService);
                myAspect.commit();
                return invoke;
            }
        });
        UserService proxy = (UserService) enhancer.create();
        return proxy;
    }
}