模拟Spring事务注解
目录
原子性
Spring 事务
模拟@Transacational实现@MyTranscational
Transcational失效场景(AOP由动态代理方式实现)，
原子性
原子性指的是整个程序中的所有操作,要么全部完成,要么全部不完成,不可能停滞在中间某个环节， 保证程序的原子性在程序设计中是不容忽视一环
Spring事务
在Spring项目中，为了保证数据库的原子性时，我们可以选择使用Spring声明式事务管理(编程式事务管理很少用)， 这种事务管理方式是建立在Spring AOP的基础上对于目标方法前后进行拦截，并在目标方法开始前创建或者加入一个事务， 在目标方法执行完之后根据执行情况提交或者回滚事务。
Spring 声明式事务可以采用 基于 XML配置 和 基于注解 两种方式实现，通常我们会选择方便的 @Transacational来实现。
模拟@Transacational实现@MyTranscational
我们自己如何去模拟实现Spring事务的注解？
在Spring框架的体系中，核心是提供IOC和AOP服务，而事务注解的实现也离不开IOC和AOP。
举个简单例子，当Spring项目启动过程中，会扫描项目包，将需要装配的bean(类似Component注解修饰对象)进行属性注入(类似Autowired修饰的字段)， 而AOP可以通过JDK动态代理对对象进行增强 （Spring AOP也可以用CGLIB实现，其原理是使用字节码增强框架ASM）， 那么在对bean注入的过程中，我们使用将AOP增强的对象注入即可。
过程如下：
定义注解MyAutowired，MyTranscational
定义接口和实现类
定义代理类
扫描包路径得到被代理类进行增强
进行代理类注入
注解MyAutowired，MyTranscational
@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
public @interface MyTranscational {
}
@Target(ElementType.FIELD)
@Retention(RetentionPolicy.RUNTIME)
public @interface MyAutowired {
String pageName() default "";
}
接口及其实现类
public interface MyService {
void execute();
}
public class MyServiceImp implements MyService {
@Override
@MyTranscational
public void execute() {
System.out.println("执行SQL");
}
}
代理类，这里需要注意的是invoke中method是接口的方法，并非实现类，如果单纯通过method判断是否 存在MyTranscational注解，那么可能会无效(接口方法没使用了MyTranscational注解)
public class MyProxy implements InvocationHandler {
private Object obj;
public MyProxy(Object obj) {
this.obj = obj;
}
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
if (obj.getClass().getMethod(method.getName()).
isAnnotationPresent(MyTranscational.class)
||
method.isAnnotationPresent(MyTranscational.class)
) {
System.out.println("开启事务");
}
Object invoke = null;
try {
invoke = method.invoke(obj, args);
} catch (Exception e) {
System.out.println("回滚");
}
return invoke;
}
}
注入的核心是利用反射将增加的对象赋值到字段中，
下方代码中main函数可以理解为一次接口请求，exe方法中：首先取到Test类中使用MyAutowired注解的字段， 如果发现使用MyAutowired注解的字段是一个接口， 那么遍历指定的包路径，寻找其子类(也可以用JDK提供的SPI：ServiceLoader)。默认情况下接口只有一个实现类，如果多个实现类，我们需要MyAutowired注解中指定实现类，否则抛出异常。
完整代码：
public class Test {
@MyAutowired
private MyService myService;
public static void main(String[] args) throws NoSuchFieldException, IllegalAccessException, IOException, ClassNotFoundException, InstantiationException {
//理解为这里是接口的调用
new Test().exe();
}
public void exe() throws NoSuchFieldException, IllegalAccessException, IOException, ClassNotFoundException, InstantiationException {
//扫描包-得到myService的实现类
Field[] fields = this.getClass().getDeclaredFields();
for (Field field : fields) {
//需要注入
if (field.isAnnotationPresent(MyAutowired.class)) {
//子类
Class<?> c = null;
//如果是接口，则找到其实现类，默认一个实现类，如果是多个MyAutowired需要指定
if (field.getType().isInterface()) {
//扫描包
String packageName = "com.studyjava.email.test.proxy";
String packageDirName = packageName.replace('.', '/');
Enumeration<URL> dirs = Thread.currentThread().getContextClassLoader().getResources(
packageDirName);
while (dirs.hasMoreElements()) {
// 获取下一个元素
URL url = dirs.nextElement();
// 得到协议的名称
String protocol = url.getProtocol();
if ("file".equals(protocol)) {
//物理路径
String filePath = URLDecoder.decode(url.getFile(), "UTF-8");
File dir = new File(filePath);
File[] dirfiles = dir.listFiles(new FileFilter() {
// 自定义过滤规则 取到以.class结尾的文件(编译好的java类文件)
public boolean accept(File file) {
return file.getName().endsWith(".class");
}
});
for (File file : dirfiles) {
String className = file.getName().substring(0,
file.getName().length() - 6);
Class<?> temp = Thread.currentThread().getContextClassLoader()
.loadClass(packageName + '.' + className);
if (temp.getSuperclass() != null)
for (Class<?> inter : temp.getInterfaces()) {
if (inter.getName().equals(field.getType().getName())) {
c = temp;
break;
}
}
}
} else if ("jar".equals(protocol)) {
//jar包处理逻辑和file处理逻辑不同
}
}
}
//
if (c == null) {
return;
}
Object instance = c.newInstance();
//增加
Object o = Proxy.newProxyInstance(instance.getClass().getClassLoader(),
instance.getClass().getInterfaces(),
new MyProxy(instance));
//赋值
field.setAccessible(true);
field.set(this, o);
this.myService.execute();
}
}
}
}
失效场景(动态代理实现的前提)
底层数据库支持事务
使用动态代理实现AOP，代理类必须实现接口，由于接口定义的方法是public的，所以java要求实现类所实现接口的方法必须是public的 （不能是protected，private等），同时不能使用static的修饰符。所以，可以实施接口动态代理的方法只能是使用“public”或“public final”修饰符的方法， 其它方法不可能被动态代理，相应的也就不能实施AOP增强，也不能进行Spring事务增强。
异常不能被方法内部消化