Spring

1.框架

高度抽取可重用代码的一种设计，具有高度的通用性（半成品软件）

  • 书城: WebUtils. java; BaseServlet; Filter
  • 打包: bookstore jar（工具类），commons-fileupload， commons-IO， commons-dbutils
  • 框架:抽取成一种高度可重用的，比如：事务控制，强大的 servlet，项目中的一些工具。它是多个可重用模块的集合，形成一个某个领域的整体解决方案

2.Spring

容器（可以管理所有的组件/类）框架

核心关注：IOC和AOP

2.1.模块划分

Spring - 图1

Test：单元测试模块

Core Container：核心容器(IOC)；黑色表示由哪些jar组成

AOP + Aspects：面向切面编程

Data Access/Integration：JDBC；ORM；TX

  • OX(xml)M

Web：

  • servlet：spring-web
  • web：spring-webmvc
  • portlet：spring-webmvc-portlet(开发web语应用的组件集成)

2.2.IOC(Inversion Of Control)

控制：控制资源的获取方式

  • 主动式：需要资源自己主动创建
  1. UserServlet{
  2.     //简单对象
  3.     private UserService userService = new UserService();
  4.     //复杂对象的创建是比较庞大的工程
  5. }
  • 被动式：资源获取不是自己主动创建，而是交给一个容器创建
  1. UserServlet{
  2.     private UserService userService;
  4.     pubilc void test(){
  5.         userService.addUser();
  6.     }
  7. }

反转：从主动的new资源变为被动的接受资源。

2.3.DI(Dependency Injection)

容器能直到哪个组件运行的时候，需要另外一个组件，容器通过反射的形式，将所需对象注入(利用反射给属性赋值)给需求对象

操作细节

@Scope(“prototype”)

  • 多实例的
    • 容器启动之前不会创建对象
    • 在获取的时候创建bean
    • 每次获取都会创建新的bean

@Scope(“single”)

  • 单实例的；默认
    • 在容器启动完成之前就已经创建好对象，保存在容器中
    • 获取任意此对象都是容器启动之前创建的对象(单例)

静态工厂：工厂本身不用创建，通过静态方法调用：

  • 对象 = 工厂类.工厂方法名();

实例工厂：工厂本身需要创建，

  • 工厂类 工厂对象 = new 工厂类();
  • 工厂对象.get对象(..);

@Autowired原理

  1. @Autowired
  2. private UserService userService;

先按照类型去容器中找到对应的组件：

  1. UserService userService = ioc.getBean(UserService.class);
  • 找到一个：找到就赋值
  • 没找到：抛异常

  • 找到多个：

    • 按照变量名作为id继续匹配：

      1. UserService(id = userService)
      2. UserServiceExt(id = UserServiceExt)
      • 匹配上：注入

      • 没有匹配上：抛异常
        解决办法：指定bean的id

        1. @Qualifier("userService")
        • 匹配上：注入

        • 没有匹配上：抛异常

          1. @Autowired(required = false)

        • 匹配不上，不抛出异常，不进行处理

方法上有Autowried：方法上的每个参数都会自动注入值

@Resource和@Autowried

@Resource：扩展性强(J2EE标准)，切换容器框架依旧可以使用，而@Autowried不行

泛型依赖注入：注入一个组件时，它的泛型也是参考标准

2.3.1.源码

  1. IOC是一个容器
  2. 容器启动的时候创建所有单例对象
  3. 可以从容器中获取bean
  1. ApplicationContext ioc = new ClassPathXmlApplicationContext();

ClassPathXmlApplicationContex

  1. public ClassPathXmlApplicationContext(String configLocation) throws BeansException {
  2.     //*
  3.     this(new String[] {configLocation}, true, null);
  4. }

↓

  1. public ClassPathXmlApplicationContext(
  2.             String[] configLocations, boolean refresh, @Nullable ApplicationContext parent)
  3.             throws BeansException {
  5.     super(parent);
  6.     setConfigLocations(configLocations);
  7.     if (refresh) {
  8.         //*所有单例bean被实例化
  9.         refresh();
  10.     }
  11. }

↓

AbstractApplicationContext

  1. @Override
  2. public void refresh() throws BeansException, IllegalStateException {
  3.     synchronized (this.startupShutdownMonitor) {
  4.         // Prepare this context for refreshing.
  5.         prepareRefresh();
  7.         // Tell the subclass to refresh the internal bean factory.
  8.         //spring解析xml配置文件，将要创建的所有bean的配置信息保存
  9.         ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();
  11.         // Prepare the bean factory for use in this context.
  12.         prepareBeanFactory(beanFactory);
  14.         try {
  15.             // Allows post-processing of the bean factory in context subclasses.
  16.             postProcessBeanFactory(beanFactory);
  18.             // Invoke factory processors registered as beans in the context.
  19.             invokeBeanFactoryPostProcessors(beanFactory);
  21.             // Register bean processors that intercept bean creation.
  22.             registerBeanPostProcessors(beanFactory);
  24.             // Initialize message source for this context.
  25.             //支持国际化功能
  26.             initMessageSource();
  28.             // Initialize event multicaster for this context.
  29.             initApplicationEventMulticaster();
  31.             // Initialize other special beans in specific context subclasses.
  32.             //留给子类的方法
  33.             onRefresh();
  35.             // Check for listener beans and register them.
  36.             registerListeners();
  38.             // Instantiate all remaining (non-lazy-init) singletons.
  39.             //*初始化所有单例bean
  40.             finishBeanFactoryInitialization(beanFactory);
  42.             // Last step: publish corresponding event.
  43.             finishRefresh();
  44.         }
  46.         catch (BeansException ex) {
  47.             if (logger.isWarnEnabled()) {
  48.                 logger.warn("Exception encountered during context initialization - " +
  49.                             "cancelling refresh attempt: " + ex);
  50.             }
  52.             // Destroy already created singletons to avoid dangling resources.
  53.             destroyBeans();
  55.             // Reset 'active' flag.
  56.             cancelRefresh(ex);
  58.             // Propagate exception to caller.
  59.             throw ex;
  60.         }
  62.         finally {
  63.             // Reset common introspection caches in Spring's core, since we
  64.             // might not ever need metadata for singleton beans anymore...
  65.             resetCommonCaches();
  66.         }
  67.     }
  68. }

↓

  1. protected void finishBeanFactoryInitialization(ConfigurableListableBeanFactory beanFactory) {
  2.         // Initialize conversion service for this context.
  3.         if (beanFactory.containsBean(CONVERSION_SERVICE_BEAN_NAME) &&
  4.                 beanFactory.isTypeMatch(CONVERSION_SERVICE_BEAN_NAME, ConversionService.class)) {
  5.             beanFactory.setConversionService(
  6.                     beanFactory.getBean(CONVERSION_SERVICE_BEAN_NAME, ConversionService.class));
  7.         }
  9.         // Register a default embedded value resolver if no bean post-processor
  10.         // (such as a PropertyPlaceholderConfigurer bean) registered any before:
  11.         // at this point, primarily for resolution in annotation attribute values.
  12.         if (!beanFactory.hasEmbeddedValueResolver()) {
  13.             beanFactory.addEmbeddedValueResolver(strVal -> getEnvironment().resolvePlaceholders(strVal));
  14.         }
  16.         // Initialize LoadTimeWeaverAware beans early to allow for registering their transformers early.
  17.         String[] weaverAwareNames = beanFactory.getBeanNamesForType(LoadTimeWeaverAware.class, false, false);
  18.         for (String weaverAwareName : weaverAwareNames) {
  19.             getBean(weaverAwareName);
  20.         }
  22.         // Stop using the temporary ClassLoader for type matching.
  23.         beanFactory.setTempClassLoader(null);
  25.         // Allow for caching all bean definition metadata, not expecting further changes.
  26.         beanFactory.freezeConfiguration();
  28.         // Instantiate all remaining (non-lazy-init) singletons.
  29.         //*初始化所有单例bean
  30.         beanFactory.preInstantiateSingletons();
  31.     }

↓

DefaultListableBeanFactory

  1. @Override
  2. public void preInstantiateSingletons() throws BeansException {
  3.    if (logger.isTraceEnabled()) {
  4.       logger.trace("Pre-instantiating singletons in " + this);
  5.    }
  7.    // Iterate over a copy to allow for init methods which in turn register new bean definitions.
  8.    // While this may not be part of the regular factory bootstrap, it does otherwise work fine.
  9.    List<String> beanNames = new ArrayList<>(this.beanDefinitionNames);
  11.    // Trigger initialization of all non-lazy singleton beans...
  12.    //按顺序创建bean
  13.    for (String beanName : beanNames) {
  14.       //根据bean的id获取bean的定义信息
  15.       RootBeanDefinition bd = getMergedLocalBeanDefinition(beanName);
  16.       //此bean不是抽象的，是单例的，不是懒加载的
  17.       if (!bd.isAbstract() && bd.isSingleton() && !bd.isLazyInit()) {
  18.          //实现了FactoryBean接口的bean
  19.          if (isFactoryBean(beanName)) {
  20.             Object bean = getBean(FACTORY_BEAN_PREFIX + beanName);
  21.             if (bean instanceof FactoryBean) {
  22.                final FactoryBean<?> factory = (FactoryBean<?>) bean;
  23.                boolean isEagerInit;
  24.                if (System.getSecurityManager() != null && factory instanceof SmartFactoryBean) {
  25.                   isEagerInit = AccessController.doPrivileged((PrivilegedAction<Boolean>)
  26.                               ((SmartFactoryBean<?>) factory)::isEagerInit,
  27.                         getAccessControlContext());
  28.                }
  29.                else {
  30.                   isEagerInit = (factory instanceof SmartFactoryBean &&
  31.                         ((SmartFactoryBean<?>) factory).isEagerInit());
  32.                }
  33.                if (isEagerInit) {
  34.                   getBean(beanName);
  35.                }
  36.             }
  37.          }
  38.          //未实现FactoryBean接口的普通bean
  39.          else {
  40.             //*创建bean的细节
  41.             getBean(beanName);
  42.          }
  43.       }
  44.    }
  46.    // Trigger post-initialization callback for all applicable beans...
  47.    for (String beanName : beanNames) {
  48.       Object singletonInstance = getSingleton(beanName);
  49.       if (singletonInstance instanceof SmartInitializingSingleton) {
  50.          final SmartInitializingSingleton smartSingleton = (SmartInitializingSingleton) singletonInstance;
  51.          if (System.getSecurityManager() != null) {
  52.             AccessController.doPrivileged((PrivilegedAction<Object>) () -> {
  53.                smartSingleton.afterSingletonsInstantiated();
  54.                return null;
  55.             }, getAccessControlContext());
  56.          }
  57.          else {
  58.             smartSingleton.afterSingletonsInstantiated();
  59.          }
  60.       }
  61.    }
  62. }

↓

AbstractBeanFactory

  1. @Override
  2. public Object getBean(String name) throws BeansException {
  3.    //*
  4.    return doGetBean(name, null, null, false);
  5. }

↓

  1. protected <T> T doGetBean(final String name, @Nullable final Class<T> requiredType,
  2.       @Nullable final Object[] args, boolean typeCheckOnly) throws BeansException {
  4.    final String beanName = transformedBeanName(name);
  5.    Object bean;
  7.    // Eagerly check singleton cache for manually registered singletons.
  8.    //先从已注册的所有单例bean中看是否存在此bean
  9.    Object sharedInstance = getSingleton(beanName);
  10.    if (sharedInstance != null && args == null) {
  11.       if (logger.isTraceEnabled()) {
  12.          if (isSingletonCurrentlyInCreation(beanName)) {
  13.             logger.trace("Returning eagerly cached instance of singleton bean '" + beanName +
  14.                   "' that is not fully initialized yet - a consequence of a circular reference");
  15.          }
  16.          else {
  17.             logger.trace("Returning cached instance of singleton bean '" + beanName + "'");
  18.          }
  19.       }
  20.       bean = getObjectForBeanInstance(sharedInstance, name, beanName, null);
  21.    }
  23.    else {
  24.       // Fail if we're already creating this bean instance:
  25.       // We're assumably within a circular reference.
  26.       if (isPrototypeCurrentlyInCreation(beanName)) {
  27.          throw new BeanCurrentlyInCreationException(beanName);
  28.       }
  30.       // Check if bean definition exists in this factory.
  31.       BeanFactory parentBeanFactory = getParentBeanFactory();
  32.       if (parentBeanFactory != null && !containsBeanDefinition(beanName)) {
  33.          // Not found -> check parent.
  34.          String nameToLookup = originalBeanName(name);
  35.          if (parentBeanFactory instanceof AbstractBeanFactory) {
  36.             return ((AbstractBeanFactory) parentBeanFactory).doGetBean(
  37.                   nameToLookup, requiredType, args, typeCheckOnly);
  38.          }
  39.          else if (args != null) {
  40.             // Delegation to parent with explicit args.
  41.             return (T) parentBeanFactory.getBean(nameToLookup, args);
  42.          }
  43.          else if (requiredType != null) {
  44.             // No args -> delegate to standard getBean method.
  45.             return parentBeanFactory.getBean(nameToLookup, requiredType);
  46.          }
  47.          else {
  48.             return (T) parentBeanFactory.getBean(nameToLookup);
  49.          }
  50.       }
  52.       if (!typeCheckOnly) {
  53.          markBeanAsCreated(beanName);
  54.       }
  56.       try {
  57.          final RootBeanDefinition mbd = getMergedLocalBeanDefinition(beanName);
  58.          checkMergedBeanDefinition(mbd, beanName, args);
  60.          // Guarantee initialization of beans that the current bean depends on.
  61.          //拿到当前bean创建之前需要的提前创建的bean。depends-on属性，若有就循环创建
  62.          String[] dependsOn = mbd.getDependsOn();
  63.          if (dependsOn != null) {
  64.             for (String dep : dependsOn) {
  65.                if (isDependent(beanName, dep)) {
  66.                   throw new BeanCreationException(mbd.getResourceDescription(), beanName,
  67.                         "Circular depends-on relationship between '" + beanName + "' and '" + dep + "'");
  68.                }
  69.                registerDependentBean(dep, beanName);
  70.                try {
  71.                   getBean(dep);
  72.                }
  73.                catch (NoSuchBeanDefinitionException ex) {
  74.                   throw new BeanCreationException(mbd.getResourceDescription(), beanName,
  75.                         "'" + beanName + "' depends on missing bean '" + dep + "'", ex);
  76.                }
  77.             }
  78.          }
  80.          // Create bean instance.
  81.          //创建bean实例
  82.          if (mbd.isSingleton()) {
  83.              //*
  84.             sharedInstance = getSingleton(beanName, () -> {
  85.                try {
  86.                   return createBean(beanName, mbd, args);
  87.                }
  88.                catch (BeansException ex) {
  89.                   // Explicitly remove instance from singleton cache: It might have been put there
  90.                   // eagerly by the creation process, to allow for circular reference resolution.
  91.                   // Also remove any beans that received a temporary reference to the bean.
  92.                   destroySingleton(beanName);
  93.                   throw ex;
  94.                }
  95.             });
  96.             bean = getObjectForBeanInstance(sharedInstance, name, beanName, mbd);
  97.          }
  99.          else if (mbd.isPrototype()) {
  100.             // It's a prototype -> create a new instance.
  101.             Object prototypeInstance = null;
  102.             try {
  103.                beforePrototypeCreation(beanName);
  104.                prototypeInstance = createBean(beanName, mbd, args);
  105.             }
  106.             finally {
  107.                afterPrototypeCreation(beanName);
  108.             }
  109.             bean = getObjectForBeanInstance(prototypeInstance, name, beanName, mbd);
  110.          }
  112.          else {
  113.             String scopeName = mbd.getScope();
  114.             final Scope scope = this.scopes.get(scopeName);
  115.             if (scope == null) {
  116.                throw new IllegalStateException("No Scope registered for scope name '" + scopeName + "'");
  117.             }
  118.             try {
  119.                Object scopedInstance = scope.get(beanName, () -> {
  120.                   beforePrototypeCreation(beanName);
  121.                   try {
  122.                      return createBean(beanName, mbd, args);
  123.                   }
  124.                   finally {
  125.                      afterPrototypeCreation(beanName);
  126.                   }
  127.                });
  128.                bean = getObjectForBeanInstance(scopedInstance, name, beanName, mbd);
  129.             }
  130.             catch (IllegalStateException ex) {
  131.                throw new BeanCreationException(beanName,
  132.                      "Scope '" + scopeName + "' is not active for the current thread; consider " +
  133.                      "defining a scoped proxy for this bean if you intend to refer to it from a singleton",
  134.                      ex);
  135.             }
  136.          }
  137.       }
  138.       catch (BeansException ex) {
  139.          cleanupAfterBeanCreationFailure(beanName);
  140.          throw ex;
  141.       }
  142.    }
  144.    // Check if required type matches the type of the actual bean instance.
  145.    if (requiredType != null && !requiredType.isInstance(bean)) {
  146.       try {
  147.          T convertedBean = getTypeConverter().convertIfNecessary(bean, requiredType);
  148.          if (convertedBean == null) {
  149.             throw new BeanNotOfRequiredTypeException(name, requiredType, bean.getClass());
  150.          }
  151.          return convertedBean;
  152.       }
  153.       catch (TypeMismatchException ex) {
  154.          if (logger.isTraceEnabled()) {
  155.             logger.trace("Failed to convert bean '" + name + "' to required type '" +
  156.                   ClassUtils.getQualifiedName(requiredType) + "'", ex);
  157.          }
  158.          throw new BeanNotOfRequiredTypeException(name, requiredType, bean.getClass());
  159.       }
  160.    }
  161.    return (T) bean;
  162. }

↓

DefaultSingletonBeanRegistry

  1. public Object getSingleton(String beanName, ObjectFactory<?> singletonFactory) {
  2.    Assert.notNull(beanName, "Bean name must not be null");
  3.    synchronized (this.singletonObjects) {
  4.       //先从
  5.       /** Cache of singleton objects: bean name to bean instance. */
  6.       //private final Map<String, Object> singletonObjects = new ConcurrentHashMap<>(256);
  7.       //拿取bean
  8.       Object singletonObject = this.singletonObjects.get(beanName);
  9.       if (singletonObject == null) {
  10.          if (this.singletonsCurrentlyInDestruction) {
  11.             throw new BeanCreationNotAllowedException(beanName,
  12.                   "Singleton bean creation not allowed while singletons of this factory are in destruction " +
  13.                   "(Do not request a bean from a BeanFactory in a destroy method implementation!)");
  14.          }
  15.          if (logger.isDebugEnabled()) {
  16.             logger.debug("Creating shared instance of singleton bean '" + beanName + "'");
  17.          }
  18.          beforeSingletonCreation(beanName);
  19.          boolean newSingleton = false;
  20.          boolean recordSuppressedExceptions = (this.suppressedExceptions == null);
  21.          if (recordSuppressedExceptions) {
  22.             this.suppressedExceptions = new LinkedHashSet<>();
  23.          }
  24.          try {
  25.             //※利用反射创建bean
  26.             singletonObject = singletonFactory.getObject();
  27.             newSingleton = true;
  28.          }
  29.          catch (IllegalStateException ex) {
  30.             // Has the singleton object implicitly appeared in the meantime ->
  31.             // if yes, proceed with it since the exception indicates that state.
  32.             singletonObject = this.singletonObjects.get(beanName);
  33.             if (singletonObject == null) {
  34.                throw ex;
  35.             }
  36.          }
  37.          catch (BeanCreationException ex) {
  38.             if (recordSuppressedExceptions) {
  39.                for (Exception suppressedException : this.suppressedExceptions) {
  40.                   ex.addRelatedCause(suppressedException);
  41.                }
  42.             }
  43.             throw ex;
  44.          }
  45.          finally {
  46.             if (recordSuppressedExceptions) {
  47.                this.suppressedExceptions = null;
  48.             }
  49.             afterSingletonCreation(beanName);
  50.          }
  51.          if (newSingleton) {
  52.             //添加创建的bean
  53.             addSingleton(beanName, singletonObject);
  54.          }
  55.       }
  56.       return singletonObject;
  57.    }
  58. }

创建好的对象最终会保存在DefaultSingletonBeanRegistry类的singletonObjects中

IOC容器之一：singletonObjects：保存单例bean

Spring - 图2

BeanFactory和ApplicationContext的区别

  • ApplicationContext是BeanFactory的子接口；
  • BeanFactory：bean工厂接口，负责创建bean实例；
    • 最底层的接口
  • ApplicationContext：容器接口，负责容器功能的实现；
    • 留给人使用的ioc接口
    • 可以基于BeanFactory创建好的对象，完成强大的容器功能

spring中最大的设计模式就是工厂模式

2.4.动态代理：

场景:计算器运行计算方法的时候进行日志记录

加日志记录:

  1. 直接编写在方法内部;不推荐，修改维护麻烦
    • 日志记录:系统的辅助功能;
    • 业务逻辑:（核心功能）
    • 耦合
  2. 希望的是
    • 业务逻辑:（核心功能）
    • 日志模块：在核心功能运行期间，自己动态的加上
    • 可以使用动态代理来将日志代码动态的在目标方法执行前后先进行执行;
  1. package com.jjj.proxy;
  3. import com.jjj.calculator.service.Calculator;
  4. import org.apache.commons.logging.Log;
  5. import org.apache.commons.logging.LogFactory;
  6. import java.lang.reflect.Proxy;
  7. import java.util.Arrays;
  9. /**
  10.  * @author <a href="jinyu52370@163.com">JJJ</a>
  11.  * @date 2020/5/8 9:30
  12.  */
  13. public class CalculatorProxy {
  14.     private static Log log = LogFactory.getLog(CalculatorProxy.class);
  16.     public static Calculator getProxy(Calculator calculator){
  17.         return (Calculator) Proxy.newProxyInstance(
  18.                 calculator.getClass().getClassLoader(),
  19.                 calculator.getClass().getInterfaces(),
  20.                 (proxy, method, args) -> {
  21.                     log.info("The method "
  22.                              + method.getName()
  23.                              + "() begins with "
  24.                              + Arrays.toString(args));
  25.                     Object result = null;
  26.                     try {
  27.                         result = method.invoke(calculator, args);
  28.                     } catch (Exception e) {
  29.                         log.info("The method "
  30.                                  + method.getName()
  31.                                  + "() throw exception: "
  32.                                  + e.getCause());
  33.                     }finally {
  34.                         log.info("The method "
  35.                                  + method.getName()
  36.                                  + "() ends with "
  37.                                  + result);
  38.                     }
  39.                     return result;
  40.                 });
  41.     }
  42. }

缺点：

  1. 写起来难
  2. 被代理对象必须实现接口(代理对象和被代理对象的唯一关联就是实现了同一个接口)

2.5.AOP

OOP:（Object Oriented Programming）面向对象编程

AOP:（Aspect Oriented Programming）面向切面编程

  • 基于OOP基础之上新的编程思想
  • 指在程序运行期间，将某段代码动态的切入到指定方法的指定位置进行运行的这种编程方式

Spring - 图3

通知方法的执行顺序：

  1. try{
  2.     @Before
  3.     {    
  4.         @Around(Before)
  5.         try{
  6.             method.invoke(obj, args);
  7.             @Around(Returning)
  8.         } catch(e){
  9.             @Around(Throwing)
  10.         } finally{
  11.             @Around(After)
  12.         } 
  13.     }
  14.     @AfterReturning
  15. } catch(e){
  16.     @AfterThrowing
  17. } finally{
  18.     @After()
  19. }

正常情况

异常情况

两个切面同时工作时，环绕只影响当前切面

切入点表达式写法：

固定格式：execution(访问权限符 返回值类型 方法全签名(参数表))
通配符：



    1. 匹配一个或多个字符：abc*z
    2. 匹配任意一个参数：abc(int, *)
    3. 匹配一层路径：com.pack.*.abc
    4. 访问权限符不能写，不写为匹配所有：但也只能匹配public，即public可写可不写
  • ..
    1. 匹配任意个数和类型的参数：abc(..)
    2. 匹配任意层数的路径：com.pack..abc

最模糊：execution( .*(..))
最精确：execution(public Double CalculatorImpl.add(Double, Double)))

2.6.声明式事务

2.6.1.编程式事务

  1. TransactionFilter{
  2.     try{
  3.         //获取连接
  4.         //设置非自动提交
  5.         chain.doFileter();
  6.         //提交
  7.     } catch(Exception e){
  8.         //回滚
  9.     } finally{
  10.         //关闭连接释放资源
  11.     }
  12. }

2.6.2.声明式事务(基于AOP的环绕通知)

快速为某个方法添加事务：

  1. 配置事务管理器
  2. 开启基于注解的事务控制模式
  3. 给事务方法加注解

事务细节：

  1. isolation
  2.     Isolation //事务的隔离级别
  3. propagation
  4.     Propagation //事务的传播行为
  6. 异常分类
  7.     运行时/非检查异常：可以不处理；
  8.         默认回滚
  9.     编译时/检查异常：try-catch 或 throws；
  10.         默认不回滚
  12. noRollbackFor
  13.     Class[] //可以让某些默认回滚的异常不回滚
  14. noRollbackForclassName
  15.     String[] //String全类名
  17. rollbackFor
  18.     Class[] //可以让某些默认不回滚的异常回滚
  19. rollbackForclassName
  20.     String[] //String全类名
  22. readonly
  23.     boolean //设置事务为只读事务
  24.     true //加快查询速度，无需进行commit等事务操作
  25. timeout
  26.     int //事务超出指定执行时长(s)后自动终止并回滚

隔离级别

读未提交：脏读

Spring - 图4

读已提交：不可重复读

Spring - 图5

可重复读(快照读)

Spring - 图6

传播行为

REQUIRED：当前事务和大事务共用一个事务

  • 当前事务的属性继承于大事务，比如timeout
  • 将之前事务的connection传递给这个方法使用

REQUIRES_NEW：当前事务新开事务，若已经有事务，则将其挂起

  • 使用新的connection

本类事务方法之间调用的是同一个事务

  1. MulServiceProxy.mulTx(){
  2.     userServiceProxy.transfer();
  3.     userServiceProxy.updateMoneyByName();
  4. }
  6. //本类方法的嵌套调用就只是一个事务
  7. UserServiceProxy.mulTx(){
  8.     transfer();
  9.     updateMoneyByName();
  10. }