spring---简介

spring

 

spring是什么？

   目的：解决企业应用开发的复杂性

   功能：使用基本的JavaBean代替EJB，并提供了更多的企业应用功能

   范围：任何Java应用

   简单来说，Spring是一个轻量级的控制反转(IoC)和面向切面(AOP)的容器框架。

   轻量——从大小与开销两方面而言Spring都是轻量的。完整的Spring框架可以在一个大小只有1MB多的JAR文件里发布。并且Spring所需的处理开销也是微不足道的。此外，Spring是非侵入式的：典型地，Spring应用中的对象不依赖于Spring的特定类。

   控制反转——Spring通过一种称作控制反转（IoC）的技术促进了松耦合。当应用了IoC，一个对象依赖的其它对象会通过被动的方式传递进来，而不是这个对象自己创建或者查找依赖对象。你可以认为IoC与JNDI相反——不是对象从容器中查找依赖，而是容器在对象初始化时不等对象请求就主动将依赖传递给它。

   面向切面——Spring提供了面向切面编程的丰富支持，允许通过分离应用的业务逻辑与系统级服务（例如审计（auditing）和事务（）管理）进行内聚性的开发。应用对象只实现它们应该做的——完成业务逻辑——仅此而已。它们并不负责（甚至是意识）其它的系统级关注点，例如日志或事务支持。

   容器——Spring包含并管理应用对象的配置和生命周期，在这个意义上它是一种容器，你可以配置你的每个bean如何被创建——基于一个可配置原型（prototype），你的bean可以创建一个单独的实例或者每次需要时都生成一个新的实例——以及它们是如何相互关联的。然而，Spring不应该被混同于传统的重量级的EJB容器，它们经常是庞大与笨重的，难以使用。

   框架——Spring可以将简单的组件配置、组合成为复杂的应用。在Spring中，应用对象被声明式地组合，典型地是在一个XML文件里。Spring也提供了很多基础功能（事务管理、持久化框架集成等等），将应用逻辑的开发留给了你。

　　所有Spring的这些特征使你能够编写更干净、更可管理、并且更易于测试的代码。它们也为Spring中的各种模块提供了基础支持。

 

项目中如何体现Spring中的切面编程?

   面向切面编程：主要是横切一个关注点,将一个关注点模块化成一个切面。在切面上声明一个通知(Advice)和切入点(Pointcut); 通知: 是指在切面的某个特定的连接点(代表一个方法的执行。通过声明一个org.aspectj.lang.JoinPoint类型的参数可以使通知（Advice）的主体部分获得连接点信息。)上执行的动作。通知中定义了要插入的方法。切入点：切入点的内容是一个表达式，以描述需要在哪些对象的哪些方法上插入通知中定义的方法。

   项目中用到的Spring中的切面编程最多的地方：声明式事务管理。

   a、定义一个事务管理器

   b、配置事务特性(相当于声明通知。一般在业务层的类的一些方法上定义事务)

   c、配置哪些类的哪些方法需要配置事务(相当于切入点。一般是业务类的方法上)

   

 

 

spring的事务如何配置

spring的声明式事务配置：
    1. <!-- 配置sessionFactory -->
	<bean id="sessionFactory"
		class="org.springframework.orm.hibernate3.LocalSessionFactoryBean">
		<property name="configLocation">
			<value>/WEB-INF/classes/hibernate.cfg.xml</value>
		</property>
	</bean>  
    2. 配置事务管理器
       <!-- 配置事务管理器 -->
	<bean id="transactionManager"
		class="org.springframework.orm.hibernate3.HibernateTransactionManager">
		<property name="sessionFactory">
			<ref local="sessionFactory" />
		</property>
	</bean>
    3. 配置事务特性
       <tx:advice id="txAdvice"  transaction-manager="transactionManager">
		<tx:attributes>
 		           <tx:method name="add*" propagation="REQUIRED"/>
                    <tx:method name="update*" propagation="REQUIRED"/>
                    <tx:method name="del*" propagation="REQUIRED"/>
                    <tx:method name="*" read-only="true"/>
                </tx:attributes>
       </tx:advice>
    4. 配置哪些类的哪些方法配置事务
       <aop:config>
           <aop:pointcut id="allManagerMethod" ession="execution(* com.yyaccp.service.impl.*.*(..))"/>
           <aop:advisor advice-ref="txAdvice" pointcut-ref="allManagerMethod">
       </aop:config>

　　

isolation设定事务的隔离级别，事务管理器根据它来控制另外一个事务可以看到本事务内的哪些数据。 

DEFAULT：默认的隔离级别，使用数据库默认的事务隔离级别
READ_COMMITTED：保证一个事务修改的数据提交后才能被另外一个事务读取。另外一个事务不能读取该事务未提交的数据。这种事务隔离级别可以避免脏读出现，但是可能会出现不可重复读和幻像读。
READ_UNCOMMITTED：这是事务最低的隔离级别，它充许别外一个事务可以看到这个事务未提交的数据。这种隔离级别会产生脏读，不可重复读和幻像读。
REPEATABLE_READ：这种事务隔离级别可以防止脏读，不可重复读。但是可能出现幻像读。它除了保证一个事务不能读取另一个事务未提交的数据外，还保证了避免不可重复读。
SERIALIZABLE：这是花费最高代价但是最可靠的事务隔离级别。事务被处理为顺序执行。除了防止脏读，不可重复读外，还避免了幻像读。

propagation定义了7个事务传播行为 
REQUIRED： 如果存在一个事务，则支持当前事务。如果没有事务则开启一个新的事务。
SUPPORTS： 如果存在一个事务，支持当前事务。如果没有事务，则非事务的执行。但是对于事务同步的事务管理器，SUPPORTS与不使用事务有少许不同。
REQUIRES_NEW 总是开启一个新的事务。如果一个事务已经存在，则将这个存在的事务挂起。
NOT_SUPPORTED 总是非事务地执行，并挂起任何存在的事务。
NEVER 总是非事务地执行，如果存在一个活动事务，则抛出异常
NESTED：如果一个活动的事务存在，则运行在一个嵌套的事务中. 如果没有活动事务, 则按TransactionDefinition.PROPAGATION_REQUIRED 属性执行。
嵌套事务一个非常重要的概念就是内层事务依赖于外层事务。外层事务失败时，会回滚内层事务所做的动作。而内层事务操作失败并不会引起外层事务的回滚。

创建对象的方式

无参构造函数

<bean id=“personService" class="cn.itcast.bean.impl.PersonServiceImpl"/>

静态工厂

<bean id="personService"  class="com.itcast.factory.PersonServiceFactory"    factory-method="createPersonService" />
public class PersonServiceFactory {
      public  static PersonService createPersonService(){
                return new PersonServiceImpl();
      }
}

实例工厂

记住概念即可

对象的scope

 

singleton(默认值)

 

 在每个Spring IoC容器中一个bean定义只有一个对象实例(共享)。

 

  默认情况下会在容器启动时初始化bean，但我们可以指定Bean节点的lazy-init=“true”来延迟初始化bean，这时候，只有第一次获取bean会才初始化bean。如：

 

 <bean id="xxx" class="cn.itcast.OrderServiceBean" lazy-init="true"/>

 

如果想对所有bean都应用延迟初始化，可以在根节点beans设置default-lazy-init=“true“，如下： 

 

<beans default-lazy-init="true“ ...> 

prototype

      允许bean可以被多次实例化(使用一次就创建一个实例) . Spring不能对一个prototype bean的整个生命周期负责.这就意味着清楚prototype作用域的对象并释放任何prototype bean所持有的昂贵资源都是客户端的责任。

Request

 

Session

 

 Global session

 

依赖注入(DI)

依赖注入的基本原则是：应用组件不应该负责查找资源或者其他依赖的协作对象。配置对象的工作应该由IoC容器负责，“查找资源”的逻辑应该从应用组件的代码中抽取出来，交给IoC容器负责。

 

代理

JDK的动态代理

必须具备四个条件：

          目标接口

          目标类

          拦截器

          代理类

总结：1、因为利用JDKProxy生成的代理类实现了接口，所以目标类中所有的方法在代理类中都有。

2、生成的代理类的所有的方法都拦截了目标类的所有的方法。而拦截器中invoke方法的内容正好就是代理类的各个方法的组成体。

          3、利用JDKProxy方式必须有接口的存在。

          4、invoke方法中的三个参数可以访问目标类的被调用方法的API、被调用方法的参数、被调用方法的返回类型。

CGLIB做代理

1、 CGlib是一个强大的,高性能,高质量的Code生成类库。它可以在运行期扩展Java类与实现Java接口。

2、 用CGlib生成代理类是目标类的子类。

3、 用CGlib生成 代理类不需要接口

4、 用CGLib生成的代理类重写了父类的各个方法。

5、 拦截器中的intercept方法内容正好就是代理类中的方法体

spring有两种代理方式：

1. 若目标对象实现了若干接口，spring使用JDK的java.lang.reflect.Proxy类代理。

      优点：因为有接口，所以使系统更加松耦合

      缺点：为每一个目标类创建接口

1. 若目标对象没有实现任何接口，spring使用CGLIB库生成目标对象的子类。

      优点：因为代理类与目标类是继承关系，所以不需要有接口的存在。

      缺点：因为没有使用接口，所以系统的耦合性没有使用JDK的动态代理好。

AOP概念：

1. Aspect(切面)

比如说事务、权限等，与业务逻辑没有关系的部分

1. joinpoint(连接点)

目标类的目标方法。（由客户端在调用的时候决定）

1. Pointcut(切入点)

所谓切入点是指我们要对那些拦截的方法的定义.

 被纳入spring aop中的目标类的方法。

1. Advice(通知)

所谓通知是指拦截到joinpoint之后所要做的事情就是通知.通知分为前置通知,后置通知,异常通知,最终通知,环绕通知(切面要完成的功能)

1. Target(目标对象):

代理的目标对象

1. Weaving(织入)

是指把切面应用到目标对象来创建新的代理对象的过程.切面在指定的连接点织入到目标对象

JDKProxy代理	SpringAop
目标对象	目标对象
拦截器类	切面
拦截器类中的方法	通知
被拦截到的目标类中方法的集合	切入点
在客户端调用的方法（目标类目标方法）	连接点
代理类	AOP代理
代理类的代理方法生成的过程	织入

通知根据拦截目标类中的目标方法的位置不一样可以分为：前置通知、后置通知、最终通知、环绕通知、异常通知

aop

代理对象的方法体就把事务和目标方法结合在一起了，这样做的目的就是为了让目标类的目标方法和事务的方法松耦合

Aop的概念

切面

事务、日志、安全性的框架，权限等就是切面

通知

切面中的方法就是通知

切入点

只有符合切入点的条件，才能让通知和目标方法结合在一起

织入

形成代理对象方法体的过程

好处：事务、日志、安全性框架、权限、目标方法之间完全是松耦合的

springAOP的具体加载步骤：

   1、当spring容器启动的时候，加载了spring的配置文件

   2、为配置文件中所有的bean创建对象

   3、spring容器会解析aop:config的配置

       1、解析切入点表达式，用切入点表达式和纳入spring容器中的bean做匹配

            如果匹配成功，则会为该bean创建代理对象，代理对象的方法=目标方法+通知

            如果匹配不成功，不会创建代理对象

   4、在客户端利用context.getBean获取对象时，如果该对象有代理对象则返回代理对象，如果代理对象，则返回目标对象

 

说明：如果目标类没有实现接口，则spring容器会采用cglib的方式产生代理对象，如果实现了接口，会采用jdk的方式

通知：

   1、前置通知

      1、在目标方法执行之前执行

      2、无论目标方法是否抛出异常，都执行，因为在执行前置通知的时候，目标方法还没有执行，还没有遇到异常

   2、后置通知

      1、在目标方法执行之后执行

      2、当目标方法遇到异常，后置通知将不再执行

      3、后置通知可以接受目标方法的返回值，但是必须注意：

               后置通知的参数的名称和配置文件中returning="var"的值是一致的

   3、最终通知：

      1、在目标方法执行之后执行

      2、无论目标方法是否抛出异常，都执行，因为相当于finally

   4、异常通知

      1、接受目标方法抛出的异常信息

      2、步骤

           在异常通知方法中有一个参数Throwable  ex

           在配置文件中

              <aop:after-throwing method="throwingMethod" pointcut-ref="perform" throwing="ex"/>

   5、环绕通知

       1、如果不在环绕通知中调用ProceedingJoinPoint的proceed，目标方法不会执行

       2、环绕通知可以控制目标方法的执行

 

OpenInSessionView

      由于使用的是spring的声明式事务处理方式，所以在调用this.getHibernateTemplate().load方法时，使用了hibernate的懒加载技术。当把一个实体Bean从数据库中加载完以后，只能加载其ID值。这个时候spring的声明式事务处理方式已经把session给关闭掉了。所以当值在页面输出时会产生异常。

处理方式为：OpenSessionInview模式。