spring

Spring的特点

1、  低侵入式设计，代码污染极低。（struts2中也有）

2、  独立于各种应用服务器，spring的应用真的实现写一次到处运行。

3、  DI(Dependency Injection)机制降低了替换业务对象的复杂性。

4、  高度开放性，并不强制。贯穿表现层、业务层、持久层。

 

Sprint体系结构----七大部分

1、  spring MVC

2、  对web的支持

3、  核心机制（DI（依赖注入）于IoC（Inversion of Control控制反转））

4、  Context

5、  DAO支持

6、  Orm(Object-Relattional Mapping)对象关系映射

7、  AOP(aspect oriented programming)

 

1.什么是spring/介绍下spring?
  Spring是一个轻量级的控制反转(IoC)和面向切面(AOP)的容器框架.
  spring的设计思想是，单例模式和工厂模式。
 
事务：在Java中分为三种:1.jdbc事务也叫局部事务；2.jta事务也叫全局事务；3.容器事务。
1、JDBC事务控制的局限性在一个数据库连接内，但是其使用简单。
2、JTA事务的功能强大，事务可以跨越多个数据库或多个DAO，使用也比较复杂。
3、容器事务，主要指的是J2EE应用服务器提供的事务管理，局限于EJB应用
事务的实现划分：1.编程式事务；2.声明式事务。
事务的ACID属性是： ACID是原子性（atomicity）、一致性（consistency）、隔离性（isolation）和持久性（durability）的缩写。事务的原子性表示事务执行过程中的任何失败都将导致事务所做的任何修改失效。一致性表示当事务执行失败时，所有被该事务影响的数据都应该恢复到事务执行前的状态。隔离性表示在事务执行过程中对数据的修改，在事务提交之前对其他事务不可见。持久性表示已提交的数据在事务执行失败时，数据的状态都应该正确。

2.spring的事务处理?

  Spring把事务分为两种一种是：编程式事务，一种是声明式事务。编程式事务是侵入式事务比较灵活，声明式事
  务是非侵入式的事务。声明式事务只需在配置文件中配置，而不需要去操作逻辑代码。而编程式事务则要操作逻
  辑代码。存在重复的代码比较多，相对繁琐，而且不利于系统的扩展；

  Spring提供两种方式的编程式事务管理：
       使用 TransactionTemplate
       直接使用一个 PlatformTransactionManager 实现

  1.spring的事务管理器
   (1).org.springframework.jdbc.datasource.DataSourceTransactionManager在单一的JDBC DataSource
     中管理事务.
   (2).org.springframework.orm.hibernate.HibernateTransactionManager，当持久化机制是hibernate
     时，用其管理事务.
   (3).org.springframework.orm.jdo.JdoTransactionManager，当JDO用做持久化时，用其管理事务.
   (4).org.springframework.transaction.jta.JtaTransactionManager，使用JTA实现事务，在事务
     跨越多个资源时必须使用.
   (5).org.springframework.orm.ojb.PersistenceBrokerTransactionManager，当Apache哦OJB用做
     持久化时，用其管理事务.
  2.事务属性
   (1).传播行为
     1.PROPAGATION_MANDATORY:要求调用该方法的线程必须处于事务环境中，否则抛出异常。
     2.PROPAGATION_NESTED:如果执行该方法的线程已处于事务环境下，依然启动新的事务，方法在
       嵌套的事务里执行。如果执行该方法的线程并未处于事务中，也启动新的事务，然后执行该方法，
      此时与PROPAGATION_REQUIRED相同。
     3.PROPAGATION_NEVER:不允许调用该方法的线程处于事务环境下，如果调用该方法的线程处于事务
      环境下，则抛出异常。
     4.PROPAGATION_NOT_SUPPORTED:如果调用该方法的线程处于在事务中，则先暂停当前事务，然后
      执行该方法。
     5.PROPAGATION_REQUIRED：要求在事务环境中执行该方法，如果当前执行线程已处于事务中，则
      直接调用， 如果当前执行线程不已处于事务中，则启动新的事务后执行该方法。
     6.PROPAGATION_REQUIRES_NEW:该方法要求有一个在新的事务环境中执行，如果当前执行线程已处
      于事务中，先暂停当前事务,启动新的事务后执行该方法；如果当前执行线程不已处于事务中，
   则启动新的事务后执行该方法。
     7.PROPAGATION_SUPPORTS:如果当前执行线程已处于事务中，则使用当前事务，否则不使用事务。
   (2).隔离级别
     1.脏读(Dirty read):一个事务读取了另一个事务修改但未提交的数据
     2.不可重复读(Nonrepeatable read):一个事务执行相同的查询两次或多次，但每次查询结果头不
       相同.
     3.幻读(Phantom read):一个事务读取几行记录后，另一并发事务插入一些记录时.
   (3).只读提示
   (4).事务超时间隔

   Spring配置文件中关于事务配置总是由三个组成部分，分别是DataSource、TransactionManager和代理机制这三部分

     spring事务管理相关的接口:
     TransactionDefinition:代表一个事物,描述了事务的隔离级别, 超时时间,事务是否只读, 传播规则等等;
     TransactionStatus:描述事物的状态;
     PlatformTransactionManager:事务管理器接口, 只定义了3个方法:getTransaction()获取事务的状态; commit();rollback();
     事务管理器的实现类有多种,根据具体的持久层框架的不同而不同;

    前面加上 "-" 时，表示发生指定异常时撤消操作，如果前面加上 "+"，表示发生异常时立即提交。默认为减号。

    编程式的事务管理

　　当你只有很少的事务操作时，编程式事务管理通常比较合,可以清楚地控制事务的边界，也就是让您自行实现事务开始时间、撤消 操作的时机、结束时间等，可以实现细粒度的事务控制。如果用声明式事务管理有杀鸡用牛刀的感觉

　　声明式的事务管理
    
 如果你的应用中存在大量事务操作，那么声明式事务管理通常是值得的

　　然而多数的情况下，事务并不需要细粒度的控制，而是采用声明式的事务管理，好处是Spring事务管理的相关API可以不用介入程 序之中，从对象的角度来看，它并不知道自己正被纳入事务管理之中，在不需要事务管理的时候，只要在设置文件上修改一下设置，即 可移去事务管理服务。

 

二、Isolation Level(事务隔离等级):
1、Serializable：最严格的级别，事务串行执行，资源消耗最大；
2、REPEATABLE READ：保证了一个事务不会修改已经由另一个事务读取但未提交（回滚）的数据。避免了“脏读取”和“不可重复读取”的情况，但是带来了更多的性能损失。
3、READ COMMITTED:大多数主流数据库的默认事务等级，保证了一个事务不会读到另一个并行事务已修改但未提交的数据，避免了“脏读取”。该级别适用于大多数系统。
4、Read Uncommitted：保证了读取过程中不会读取到非法数据。隔离级别在于处理多事务的并发问题。
我们知道并行可以提高数据库的吞吐量和效率，但是并不是所有的并发事务都可以并发运行，这需要查看数据库教材的可串行化条件判断
     一般用这个：isolation="READ_COMMITTED"

3.spring web?

4.spring MVC?
  1.spring的MVC组成部分:
   M:
   V:
   C:核心控制器(DispatcherServlet),业务控制器
  2.spring MVC的缺点:
   (1).与servlet API耦合.
   (2).角色划分太细，过于繁琐，降低了应用，程序的开发效率.      
   (3).有过度追求设计完美的嫌疑，所以导致spring的MVC得不到广泛的使用.

5.spring context作用?

6.spring IoC(IOC=Inversion Of Control)?
   调用者不再创建被调用者的实例，由spring框架实现，故称控制反转。创建好实例然后再注入调用者，又称依赖
   注入。IoC好处:将应用程序的配置和依赖性规范与实际的应用代码程序分开。

7.spring组成部分(模块)?
  Spring框架有七个模块组成组成，这7个模块(或组件)均可以单独存在，也可以与其它一个或多个模块联合使用，
  主要功能表现如下：
  (1).Spring 核心容器(Core):提供Spring框架的基本功能。核心容器的主要组件是BeanFactory，它是工厂模式
      的实现。BeanFactory使用控制反转(Ioc)模式将应用程序的配置和依赖性规范与实际的应用代码程序分开。
  (2).Spring AOP:通过配置管理特性，Spring AOP模块直接面向方面的编程功能集成到了Spring框架中，所以可
      以很容易的使Spring框架管理的任何对象支持 AOP。Spring AOP模块为基于Spring的应用程序中的对象提供
   了事务管理服务。通过使用Spring AOP，不用依赖于EJB组件，就可以将声明性事务管理集成到应用程序中。
  (3).Spring ORM:Spring框架集成了若干ORM框架,从而提供了ORM的对象关系工具,其中包括 JDO、Hibernate、
      iBatis和TopLink。所有这些都遵从Spring的通用事务和DAO异常层结构。
  (4).Spring DAO:JDBC DAO抽象层提供了有意义的异常层次的结构，可用该结构来管理异常处理和不同数据供应
      商抛出的异常错误信息。异常层次结构简化了错误处理，并且大大的降低 了需要编写的异常代码数量(例如，
   打开和关系连接)。Spring DAO的面向JDBC的异常遵从通用的DAO异常层结构。
  (5).Spring WEB:Web上下文模块建立在上下文模块（Context）的基础之上，为基于Web服务的应用程序提供了上
      下文的服务。所以Spring框架支持 Jakarta Struts的集成。Web模块还简化了处理多部分请求及将请求参数
   绑定到域对象的工作。
  (6).Spring上下文(Context):Spring上下文是一个配置文件，向Spring框架提供上下文信息。Spring上下文包括
      企业服务，例如 JNDI、EJB、电子邮件、国际化校验和调度功能。
  (7).Spring MVC:Spring的MVC框架是一个全功能的构建Web应用程序的MVC实现。通过策略接口，MVC框架变成为
      高度可配置的，MVC容纳的大量视图技术，包括JSP、Velocity、Tiles、iText和Pol

8.spring的依赖注入方式?
  1.设值注入:是在xml文件里面配置property,例如:
      <bean id="china" class="com.person.impl.ChinaPerson">
  <property name="ax">
   <ref local="tieAx" /> //local指的是本xml文件里面配置的bean id。
  </property>
   </bean>
  介绍下这个例子:就是说给com.person.impl.ChinaPerson类里面的ax字段，把本地的bean tieAx对象注入到ax里面去.
  2.构造注入:要提供一个带参数的构造方法,例如:
     public EnglishPerson(Ax ax) {
        this.ax = ax;
     }
  然后在进行配置xml文件例如:
  <bean id="english" class="com.person.impl.EnglishPerson">
  <constructor-arg>
   <ref bean="muAx" />
  </constructor-arg>
  </bean>
  3.接口注入(基本不用)
    public class ClassA {
　　  private InterfaceB clzB;
　　  public init() {
　　    Ojbect obj =Class.forName(Config.BImplementation).newInstance();
　　    clzB = (InterfaceB)obj;
　　  }
　　}
9.spring AOP?

目标对象就是我们要切入的对象！ 处理（通知） 就是我们要切入
的具体动作，一般用一个对象来代替； AOP代理就是我们如何将一
个通知切入到某个对象的具体操作类，这个类一般是一个代理模式
类，内部实现 用到了java反射机制实现了动态代理！切入点具体说
来就是我们要切入的目标对象的方法；而由多个切入点就组成了一个
切面，要加入哪个方面的功能(如日志方面,事务方面), 这样就达到了我们的面向方面编程

  将系统中通用的需求功能隔离出来形成一个功能模块，并将这个模块切入到应用程序当中。
  AOP追求的是调用者与被调用者的解耦，从而消除了OOP引起的代码混乱和分散问题，增强了
  系统的可维护性和代码的重用性。
  1.面向方面编程:
      面向方面编程，是因为AOP面向日志、事务、安全、权限等这些功能，所以称为面向方面编程.
  2.面向切面编程:
   连接点-->切入点-->切面-->方面
   连接点是某个方法调用，切入点是方法的集合，切面类的集合.切面是由点组成面，横切多个对象
  3.处理:spring的处理
    处理有五种:
  (1).before advice(前置通知)
     是在方法调用前调用，没有返回值，通常意外情况下,会继续运行下一步方法.记住的一点是没有返回值。
  (2).after advice(后置通知)
      是在方法调用后调用，有返回值，记住的一点是有返回值。
  (3).around advice(环绕通知)
     around是针对具体的某个切入点的方法,around的切入类型是就这个方法的内部调用,是通过java的元数据,
  在运行时通过Method.invoke来调用,具有返回值,当发生意外的时候会终止.记住的一点是有返回值。
  (4).throws advice(异常通知)
  (5).introduce advice(引入通知)
    引入通知是一种特殊的通知，它能将新的成员变量、成员方法引入到目标类中。它不能作用于任何切入点，
    因为它只作用于类层次，而不是方法层次。实现引入通知需要实现IntroductionAdvisor和IntroductionInterceptor接口。
       引入通知不能调用proceed方法。Advisor必须针对每个实例，并且是有状态的。
       引入通知的效果类似于设计模式中的访问者模式(Visitor Pattern)。
  4.目标对象:被处理的类
  5.AOP代理:具体实现
    (1).jdk动态代理 面向接口(默认实现)
 (2).cglib代理   面向具体实现
  6.AOP的特征:
   (1).各步骤之间的良好隔离性
   (2).源代码的无关性
  7.AOP的好处:
   (1).消除了编码模块之间的依赖。
   (2).可以在任意阶段，向已有功能模块中填加新功能，且不侵入原有功能。

10.spring的核心类有哪些？各有什么作用?
  BeanFactory:
    BeanFactory负责根据配置文件创建Bean实例，可以配置的项目有：
    Bean属性值及依赖关系(对其他Bean的引用)
    Bean创建模式(是否Singleton模式，即是否只针对指定类维持全局唯一的实例)
    Bean初始化和销毁方法
    Bean的依赖关系
  BeanWrapper：提供统一的get及set方法
    根据给定的配置文件，BeanFactory从中读取类名、属性名/值，然后通过Reflection机制进行Bean加载和
 属性设定。
  ApplicationContext:提供框架的实现，包括BeanFactory的所有功能
    国际化(getMesage)
    资源管理:可以直接读取一个文件的内容(getResource)

11.spring框架中bean的作用域?
   在spring 2.0前，作用域只有singleton和prototype，在spring 2.0后新增了request，session，global session
   五种作用域(版本):
    request、session、global session使用的时候，首先要在初始化web的web.xml中做如下配置：
 <listener>
       <listener-class>org.springframework.web.context.request.RequestContextListener</listener-class>
    </listener>
   (1).singleton(默认):
      一个bean的作用域为singleton, 那么Spring IoC容器中只会存在一个共享的bean实例，
      并且所有对bean的请求，只要id与该bean定义相匹配，则只会返回bean的同一实例。
   (2).prototype:
      Prototype作用域的bean会导致在每次对该bean请求(将其注入到另一个bean中，或者以程序的
   方式调用容器的getBean()方法)时都会创建一个新的bean实例，一般对所有有状态的bean应该使用prototype作用域，
   而对无状态的bean则应该使用singleton作用域。对于prototype作用域的bean，有一点非常重要，
   那就是Spring不能对一个prototype bean的整个生命周期负责：容器在初始化、配置、装饰或者是
   装配完一个prototype实例后，将它交给客户端，随后就对该prototype实例不闻不问了。
   (3).request:
     request表示该针对每一次HTTP请求都会产生一个新的bean，同时该bean仅在当前HTTP request内有效
   (4).session:
     session作用域表示该针对每一次HTTP请求都会产生一个新的bean，同时该bean仅在当前HTTP session内有效，
   (5).global session(portlet)：
      global session作用域类似于标准的HTTP Session作用域，不过它仅仅在基于portlet的web应用中才有意义。
   Portlet规范定义了全局Session的概念，它被所有构成某个 portlet web应用的各种不同的portlet所共享。
   在global session作用域中定义的bean被限定于全局portlet Session的生命周期范围内。如果你在web中使用
   global session作用域来标识bean，那么，web会自动当成session类型来使用。

   这些都是写在ben标签里的scope中即scope="request"

12.spring框架中bean的生命周期?
  (1).bean定义
    在配置文件里面用<bean></bean>来进行定义。
  (2).bean初始化
    有两种方式初始化:
 A.在配置文件中通过指定init-method属性来完成
 B.实现org.springframwork.beans.factory.InitializingBean接口
  (3).bean调用
    有三种方式可以得到bean实例，并进行调用。
  (4).bean销毁
    销毁有两种方式
 A.使用配置文件指定的destroy-method属性
 B.实现org.springframwork.bean.factory.DisposebleBean接口

当一个bean实现了InitializingBean和BeanPostProcessor接口覆盖里面的方法，且也配置了init-method=“”,它会先执行InitializingBean里面的方法，然后init-method=""指定的方法，最后是BeanPostProcessor里的方法。
<!-- 该 BeanPostProcessor 将自动起作用，对标注 @Autowired 的 Bean 进行自动注入 -->
    <bean class="org.springframework.beans.factory.annotation.AutowiredAnnotationBeanPostProcessor"/>

13.spring的特点和优点?
  (1).轻量级,低侵入的设计
  (2).DI机制降低了业务对象替换的复杂性
  (3).Spring为数据存取提供了一致的框架，不论是使用JDBC或O/R mapping产品(Hibernate)
  (4).Spring能消除在许多工程上对Singleton的过多使用
  (5).Spring并不完全依赖于Spring，开发者可自由选用Spring框架的部分或全部
  (6).spring不依赖于web容器.

14.介绍下ORM?
   O-R Mapping(Object-Relational-Mapping对象关系映射)是一种为了解决面向对象与关系数据库存在的
   互不匹配的现象的技术。 简单的说，ORM是通过使用描述对象和数据库之间映射的元数据，将java程序
   中的对象自动持久化到关系数据库中。
   定义:与其说是一种技术，不如说一种规范.
   介绍一下ORM的产品:
    1.Hibernate
      灵活的设计，优秀的性能，齐全的文档。
    2.Entity Bean (EJB)
      是一个重量级，成本高，开发周期长，学习曲线非常陡。
    3.ibatis
     是Apche子项目，说是ORM技术更倾向于SQL-Mapping技术，相对于Hibernate的完全面向对象，Ibatis更加灵活，
     但需要的代码量更大，而且需要直接编写sql语句.
    4.Toplink是oracle公司的.
    5.JDO(Java Data Object) 是sun公司的.
 
15.Dao的好处:
  (1).减少代码开发量，提供工作效率。
  (2).业务逻辑与持久层(数据层)的分离，使数据库与操作更为清晰。
  (3).降低资源消耗提供系统性能。
  (4).数据访问独立到了一层，倾向于面向接口编程，修改具体实现类不影响系统运行，降低了代码的耦合度，
      提高扩展。
  组成部分:
  (1).接口
  (2).实现类
  (3).pojo
  (4).Dao实例
  三：DAO的好处
 .DAO设计模式的优点：
  (1)DAO模式抽象出数据访问方式，业务逻辑层访问数据源时完全感觉不到数据源的存在。
  软件工厂中有一条很重要的法则：一个对象对其他对象的了解越少越好，了解越少就意味着依赖越少，可复用性越高。
  
  (2)DAO将数据访问集中在独立的一层，因为所有的数据访问都由DAO代理，这层独立的DAO将
  数据访问的实现和系统的其余部分剥离，将数据访问集中，使得系统更具可维护性。
  
  (3)DAO降低了业务逻辑层的复杂度。DAO管理复杂的数据访问，从而简化了业务逻辑层。
  所有与数据访问的实现有关的代码(例如SOL语言等)都不写在业务逻辑层里，
  业务逻辑层可集中处理业务逻辑，提高了代码的可读性和生产率。
  
  (4)DAO有助于提升系统的可移植性。DAO模式通过将数据访问划分为抽象层和实现层，
  分离数据使用和数据访问的实现细节。这意味着业务层与数据访问的底层细节无关，
  也就是说，可以在保持上层机构不变的情况下，通过切换底层实现来修改数据访问的具体机制，提高了系统的可复用性。
  
  (5)DAO组件依赖于数据库系统，提供数据库访问接口，只要数据库没有重构，
  DAO层通常无须改写。DAO层透明地分离数据库与业务逻辑层，业务逻辑层专注于业务逻辑的实现，而无须关心持久层访问的实现。
  
  (6)DAO模式的进一步改良。由于DAO层已实现所有的数据访问，业务逻辑层只需调用DAO接口，
  因此业务逻辑层要使用Facade模式包装DAO。为实现跨数据库平台移植，支持不同数据访问机制之间的可配置切换，
  需在DAO层引入Factorv模式、Proxy模式和Strategy模式，则可方便地在不同数据存储方式间切换。
  然而，采用DAO模式，系统在请求数据端和数据服务端之间增加一层，增加了系统的复杂度；
  新增加的一层需要额外的设计与实现，增加了工作量；还需引入工厂甚至抽象工厂，增加了设计的复杂度。
  总的来说，DAO将数据持久层与业务逻辑层分离，提高了软件的可扩展性，可维护性和可复用性。
  
四：.Dao模式的好处：

                1.减少代码开发量,提高工作效率
                2.业务逻辑层与持久层(数据层)的分离,使数据与操作更为清晰.
                3.降低资源消耗,提高系统性能.
                4.数据访问独立到了一层,修改具体实现类,不影响系统的架构运行.
 
16.spring有三种方式读取配置文件:
  (1).XmlBeanFactory
  (2).FileSystemXmlApplicationContext
  (3).ClassPathXmlApplicationContext
  例如:
   InputStream is = new FileInputStream("beans.xml");
   InputStreamResource isr = new InputStreamResource(is);
   BeanFactory beanFactory = new XmlBeanFactory(isr);
     
   Spring给出一些BeanFactory的实现类，其中最为常用的是XmlBeanFactory。
   1.通过文件系统
    Resource res = new FileSystemResource("beans.xml");
    XmlBeanFactory factory = new XmlBeanFactory(res);
   2.通过类路径
    ClassPathResource res = new ClassPathResource("beans.xml");
    XmlBeanFactory factory = new XmlBeanFactory(res);
   3.通过ApplicationContext加载
    ClassPathXmlApplicationContext appContext = new ClassPathXmlApplicationContext(
    new String[] {"beans1.xml", "beans1.xml"});
    BeanFactory factory = (BeanFactory) appContext;
 
17.Spring和Struts的区别？
  strusts：是一种基于MVC模式的一个web层的处理。
  Spring:提供了通用的服务，ioc/di aop,关心的不仅仅web层，应当j2ee整体的一个服务，可以很容易融合不
  同的技术struts hibernate ibatis ejb remote springJDBC springMVC等。

18.非业务编程，包括日记、事务、权限等都是属于非业务编程。而非业务编程都可以用spring来解决。
 
19.spring提供了hibernate模板，jdbc模板。实际内部就是模板模式。

20.BeanFactory是IoC容器的核心接口。 它的职责包括：实例化、定位、配置应用程序中的对象及建立这些对象间的依赖

在Spring中，那些组成你应用程序的主体(backbone)及由Spring IoC容器所管理的对象，被称之为bean。 简单地讲，bean就是由Spring容器初始化、装配及管理的对象，除此之外，bean就与应用程序中的其他对象没有什么区别了。 而bean定义以及bean相互间的依赖关系将通过配置元数据来描述。

得到BeanFactory的方法：
  //        InputStream is = new FileInputStream("beans.xml");
//  InputStreamResource isr = new InputStreamResource(is);
//  BeanFactory beanFactory = new XmlBeanFactory(isr);
//     
//     Spring给出一些BeanFactory的实现类，其中最为常用的是XmlBeanFactory。
//     1、通过文件系统
//     Resource res = new FileSystemResource("beans.xml");
//     XmlBeanFactory factory = new XmlBeanFactory(res);
//     2、通过类路径
//     ClassPathResource res = new ClassPathResource("beans.xml");
//     XmlBeanFactory factory = new XmlBeanFactory(res);
//     3、通过ApplicationContext加载
//     ClassPathXmlApplicationContext appContext = new ClassPathXmlApplicationContext(
//     new String[] {"applicationContext.xml", "applicationContext-part2.xml"});
//     BeanFactory factory = (BeanFactory) appContext;

 

AOP概念

切面（Aspect）：一个关注点的模块化，这个关注点可能会横切多个对象。事务管理是J2EE应用中一个关于横切关注点的很好的例子。在Spring AOP中，切面可以使用基于模式）或者基于@Aspect注解的方式来实现。

连接点（Joinpoint）：在程序执行过程中某个特定的点，比如某方法调用的时候或者处理异常的时候。在Spring AOP中，一个连接点总是表示一个方法的执行。

通知（Advice）：在切面的某个特定的连接点上执行的动作。其中包括了“around”、“before”和“after”等不同类型的通知（通知的类型将在后面部分进行讨论）。许多AOP框架（包括Spring）都是以拦截器做通知模型，并维护一个以连接点为中心的拦截器链。

切入点（Pointcut）：匹配连接点的断言。通知和一个切入点表达式关联，并在满足这个切入点的连接点上运行（例如，当执行某个特定名称的方法时）。切入点表达式如何和连接点匹配是AOP的核心：Spring缺省使用AspectJ切入点语法。

目标对象（Target Object）： 被一个或者多个切面所通知的对象。也被称做被通知（advised）对象。 既然Spring AOP是通过运行时代理实现的，这个对象永远是一个被代理（proxied）对象。

AOP代理（AOP Proxy）：AOP框架创建的对象，用来实现切面契约（例如通知方法执行等等）。在Spring中，AOP代理可以是JDK动态代理或者CGLIB代理。

 

spring事务：

事务是一组原子操作单元，从数据库角度说，就是一组SQL 指令，要么全部执行

成功，若因为某个原因其中一条指令执行有错误，则撤销先前执行过的所有指令

更简答的说就是：要么全部执行成功，要么撤销不执行。

事务必须服从ISO/IEC所制定的ACID原则。ACID是原子性（atomicity）、一致性（consistency）、隔离性（isolation）和持久性（durability）的缩写。

1.事务的原子性表示事务执行过程中的任何失败都将导致事务所做的任何修改失效。

2.一致性表示当事务执行失败时，所有被该事务影响的数据都应该恢复到事务执行前的状态。

3.隔离性表示在事务执行过程中对数据的修改，在事务提交之前对其他事务不可见。

4持久性表示已提交的数据在事务执行失败时，数据的状态都应该正确。

事务主要是为解决数据安全操作提出的，事务控制实际上就是控制数据的安全访问。

事物传播属性:
  1.PROPAGATION_MANDATORY:要求调用该方法的线程必须处于事务环境中，否则抛出异常。
    
  2.PROPAGATION_NESTED:如果执行该方法的线程已处于事务环境下，依然启动新的事务，方法在
       嵌套的事务里执行。如果执行该方法的线程并未处于事务中，也启动新的事务，然后执行该方法，
      此时与PROPAGATION_REQUIRED相同。
    
  3.PROPAGATION_NEVER:不允许调用该方法的线程处于事务环境下，如果调用该方法的线程处于事务
      环境下，则抛出异常。
    
  4.PEOPAGATION_NOT_SUPPORTED:如果调用该方法的线程处于在事务中，则先暂停当前事务，然后
      执行该方法。
    
  5.PEOPAGATION_REQUIRED：要求在事务环境中执行该方法，如果当前执行线程已处于事务中，则
      直接调用， 如果当前执行线程不已处于事务中，则启动新的事务后执行该方法。
    
  6.PEOPAGATION_REQUIRES_NEW:该方法要求有一个在新的事务环境中执行，如果当前执行线程已处
      于事务中，先暂停当前事务,启动新的事务后执行该方法；如果当前执行线程不已处于事务中，
   则启动新的事务后执行该方法。
    
  7.PEOPAGATION_SUPPORTS:如果当前执行线程已处于事务中，则使用当前事务，否则不使用事务。

 

Java事务的类型有三种：JDBC事务、JTA(Java Transaction API)事务、容器事务。

1.jdbc事务主要是用 Connection 对象控制的。该对象提供了两种事务模式：自动提交和手动提交。

也提供了以下控制事务的方法：

public void setAutoCommit(boolean)这个方法是用来设置事务提交的方式

public boolean getAutoCommit()这个方法是用来得到当前事务的提交方式

public void commit()事务手动提交

public void rollback()事务回滚

JDBC 事务的一个缺点是事务的范围局限于一个数据库连接。一个 JDBC 事务不能跨越多个数据库。

2、JTA(Java Transaction API)事务
JTA是一种高层的，与实现无关的，与协议无关的API，应用程序和应用服务器可以使用JTA来访问事务。

 

3.容器事务
容器事务主要是J2EE应用服务器提供的，容器事务大多是基于JTA完成，这是一个基于JNDI的，相当复杂的API实现。

spring 事务的实现方式有两种：编码实现和声明实现
 
编码有两种实现技术：
   1.用spring模板技术实现事务！

   2.用PlatformTransactionManager事务平台管理类实现事务处理！

声明实现：

   spring提供transactionManager事务事件管理高层接口

有针对DataSource 处理的DataSourceTransactionManager事务处理类

有针对Hibernate处理的HibernateTransactionManager事务处理类、

有针对EntityManager处理的JpaTransactionManager事务处理类

 同时spring提供了事务事件代理的五种方式：

1.一个代理类一个目标类

2.模板配置事务类（TransactionProxyFactoryBean）

3.拦截器（TransactionInterceptor）

4.使用Tx标签配置的拦截器

5.全注解配置