`
liusg123
  • 浏览: 17856 次
  • 性别: Icon_minigender_1
  • 来自: 上海
社区版块
存档分类
最新评论

Spring架构事务配置

阅读更多
注:引用文章,本文曾发表于it168
在Spring中进行事务配置除了定义对象自身的bean外,还需要定义一个进行事务代理的bean.如果你有n个类需要引入事务,那么你就必须定义2n个bean。维护这些bean的代价是十分昂贵的,所以必须要对事务配置进行减化。如果你是基于Spring进行架构设计,那么作为一个好的架构设计师,应该把一些公共的方面进行简化,让项目的开发人员只关心项目的业务逻辑,而不要花费太多的精力去关心业务逻辑之外的太多东西。所以作为一个好的架构就应该把事务管理进行简化,让程序员花在编程之外的工作最小化。
1. Spring声明式事务配置的几种方法
在Spring中进行事务控制首先要选择适当的事务管理器,其次为程序选择划分事务的策略。如果只有单个事务性资源,可以从“单一资源”的PlatformTransactionManger实现当中选择一个,这些实现有:DataSourceTransactionManager,HibernateTransactionManager, JdoTransactionManager,PersistenceBrokerTransactionManager和JmsTransactionManager。
根据你所采用的数据库持久化技术选择。如果你的项目运行于支持JTA的服务器,那么将选择JtaTransactionManger,将会支持多资源事务。
下表将为你选择适当的事务管理器提供参考。
技术 事务管理器 内建的事务支持
JDBC DataSurceTransactionManagerJtaTransactionManager JdbcTemplate和org.springframework.jdbc.object包中的所有类
IBATIS DataSourceTransactionManagerJtaTransactionManager SqlMapClientTemplate和SqlClientTemplate
Hibernate HibernateTransactionManagerJtaTransactionManager HibernateTemplate和HibernateInterceptor
JDO JdoTransactionManagerJtaTransactionManager JdoTemplate和JdoInterceptor
ApacheOJB PersistenceBrokerTransactionManagerJtaTransactionManager PersistenceBrokerTemplate
JMS JmsTransactionManager JmsTemplate

在划分事务时,我们需要进行事务定义,也就是配置事务的属性。事务的属性有传播行业,隔离级别,超时值及只读标志。TransactionAttribute接口指定哪些异常将导致一个回滚,哪些应该一次性提交。

(1) 使用ProxyFactoryBean 和TransactionInterceptor

<!--定义本地数据源-->

<bean id="dataSource" name="dataSource" class="org.apache.commons.dbcp.BasicDataSource" destroy-method="close">
<property name="driverClassName" value="${jdbc.driverClassName}"/>
<property name="url" value="${jdbc.url}"/>
<property name="username" value="${jdbc.username}"/>
<property name="password" value="${jdbc.password}"/>
</bean>

<!-- !定义单个jdbc数据源的事务管理器-->
<bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
  <property name="dataSource" ref="dataSource"/>
</bean>

   <!—定义拦截器-->
<bean id="transactionInterceptor"   class="org.springframework.transaction.interceptor.TransactionInterceptor">
    <property name="transactionManager">
    <ref bean="transactionManager"/>
    </property>
        <property name="transactionAttributes">
            <props>
                <prop key="insert*">PROPAGATION_REQUIRED</prop>
                <prop key="update*">PROPAGATION_REQUIRED</prop>
                <prop key="save*">PROPAGATION_REQUIRED</prop>
                <prop key="find*">PROPAGATION_SUPPORTS,readOnly</prop>
                <prop key="get*">PROPAGATION_SUPPORTS,readOnly</prop>
                <prop key="*">PROPAGATION_SUPPORTS,readOnly</prop>
            </props>
        </property>
    </bean>

<!—定义业务对象-->
<bean id="sampleService" class="com.prs.application.ehld.sample.biz.service.impl.SampleServiceImpl">
<property name="userInfoDAO" ref="com.prs.application.ehld.sample.integration.dao.userInfoDAOImpl">
</property>
</bean>

<!—定义业务对象的事务代理对象-->
<bean id="proxyFacgtoryBean" class="org.springframeword.aop.framework.ProxyFacgtoryBean">
<property name="target" ref="sampleService">
</property>
<property name="interceptorNames">
   <value>transactionInterceptor</value>
</property>
</bean>

通过ProxyFacgtoryBean和TransactionInterceptor组合使用,可以对事务进行更多的控制。所有需要事务控制的对象可以共享一个transactionInterceptor的事务属性。

(2) 使用TransactionProxyFactoryBean

<!—定义业务对象-->
<bean id="sampleService"
class="com.prs.application.ehld.sample.biz.service.impl.SampleServiceImpl">
<property name="userInfoDAO" ref="com.prs.application.ehld.sample.integration.dao.userInfoDAOImpl">
</property>
</bean>

<!—定义业务对象的事务代理对象-->
<bean id="transactionProxyFactoryBean" class="org.springframework.transaction.interceptor.TransactionProxyFactoryBean" abstract="true">
        <property name="transactionManager">
            <ref bean="transactionManager"/>
        </property>
<property name="target" ref="sampleService" />
        <property name="transactionAttributes">
            <props>
                <prop key="insert*">PROPAGATION_REQUIRED</prop>
                <prop key="update*">PROPAGATION_REQUIRED</prop>
                <prop key="save*">PROPAGATION_REQUIRED</prop>
                <prop key="find*">PROPAGATION_SUPPORTS,readOnly</prop>
                <prop key="get*">PROPAGATION_SUPPORTS,readOnly</prop>
                <prop key="*">PROPAGATION_SUPPORTS,readOnly</prop>
            </props>
        </property>
    </bean>

使用TransactionProxyFactoryBean需要为每一个代理对象都去定义自己的事务属性。

(3) 使用TransactionProxyFactoryBean及abstract属性来简化配置
这种方工也是目前使用得最多的一种声明式事务配置方法

<!--事务控制代理抽象定义 -->
<bean id="baseTransactionProxy" class="org.springframework.transaction.interceptor.TransactionProxyFactoryBean" abstract="true">
        <property name="transactionManager">
            <ref bean="transactionManager"/>
        </property>
        <property name="transactionAttributes">
            <props>
                <prop key="insert*">PROPAGATION_REQUIRED</prop>
                <prop key="update*">PROPAGATION_REQUIRED</prop>
                <prop key="save*">PROPAGATION_REQUIRED</prop>
                <prop key="find*">PROPAGATION_SUPPORTS,readOnly</prop>
                <prop key="get*">PROPAGATION_SUPPORTS,readOnly</prop>
                <prop key="*">PROPAGATION_SUPPORTS,readOnly</prop>
            </props>
        </property>
    </bean>

<!—定义业务对象-->
<bean id="sampleService"   class="com.prs.application.ehld.sample.biz.service.impl.SampleServiceImpl">
<property name="userInfoDAO" ref="com.prs.application.ehld.sample.integration.dao.userInfoDAOImpl">
</property>
</bean>

<!—定义业务对象的事务代理对象-->
<bean id="sampleServiceProxy" parent="baseTransactionProxy">
<property name="target"
ref="com.prs.sampleService">
</property>
</bean>

使用abstract属性,可以让代理对象可以共享一个定义好的事务属性,使配置简化。

(4)使用BeanNameAutoProxyCreator
   <!—定义拦截器-->
<bean id="transactionInterceptor" class="org.springframework.transaction.interceptor.TransactionInterceptor">
    <property name="transactionManager">
    <ref bean="transactionManager"/>
    </property>
        <property name="transactionAttributes">
            <props>
                <prop key="insert*">PROPAGATION_REQUIRED</prop>
                <prop key="update*">PROPAGATION_REQUIRED</prop>
                <prop key="save*">PROPAGATION_REQUIRED</prop>
                <prop key="find*">PROPAGATION_SUPPORTS,readOnly</prop>
                <prop key="get*">PROPAGATION_SUPPORTS,readOnly</prop>
                <prop key="*">PROPAGATION_SUPPORTS,readOnly</prop>
            </props>
        </property>
    </bean>


<!—定义bean别名自动代理创建器-->
<bean id="autoProxyCreator"
class="org.springframework.aop.framework.autoproxy.BeanNameAutoProxyCreator">
   <property name="interceptorNames">
      <value>transactionInterceptor</value>
   </property>
   <property name="beanNames">
   <list>
     <idref local="sampleService"/>
   </list>
   </property>
</bean>

<!—定义业务对象-->
<bean id="sampleService"
class="com.prs.application.ehld.sample.biz.service.impl.SampleServiceImpl">

<property name="userInfoDAO" ref="com.prs.application.ehld.sample.integration.dao.userInfoDAOImpl">
</property>
</bean>

使用BeanNameAutoProxyCreator可以由框架来提供适当的代理,由一个transactionInterceptor统一定义事务属性,只需要把需要事务控制的bean加到beannames的列表。
  对于需要大量声明式事务的bean,BeanNameAutoProxyCreator是十分方便的。减少了代理bean的定义,还可以灵活的决定一个bean是否进行事务控制。

上面四种方法是在Spring中常见的声明式事务配置方法,其中使用TransactionProxyFactoryBean及abstract属性进行配置是最常见的简化方法。
我们暂且把需要进行事务控制的bean叫事务bean.把依赖和调用它的bean叫做业务bean。对事务bean进行代理叫做事务代理bean.

1. 使用ProxyFactoryBean 和TransactionInterceptor,可以由一个TransactionInterceptor统一定义事务属性,对于每一个事务bean都需要再定义一个事务代理bean。如果有n个事务bean,那么就需要定义和维护2n个bean。并且注入到业务bean的不是事务bean本身,而是要求用事务代理bean注入。这增加了理解的难度。
2. 使用TransactionProxyFactoryBean需要为每一个事务代理bean都定义自己的事务属性,除了需要维护2n个bean外,还需要为每一个事务代理bean定义事务属性。可以说是最麻烦的。同样需要把事务代理bean注入到业务bean,增加了理解的难度和项目的复杂度。
3. 使用TransactionProxyFactoryBean及abstract属性是对使用TransactionProxyFactoryBean的一种简单化配置,可以让所有的事务bean共享一致的事务属性定义。需要维护2n个bean,需要把事务代理bean注入到业务bean。
4. 使用BeanNameAutoProxyCreator最适合在框架中使用,只需要维护n个bean。也无需要事务代理bean。直接把事务bean注入业务bean中。但是它必须把需要事务控制的bean加到beanNames列表中。

2.类型自动代理创建器BeanClassTypeAutoProxyCreator
得于BeanNameAutoProxyCreator的启示,BeanNameAutoProxyCreator可以实现框架来实现自动代理。它只是把需要代理的bean加入beanNames属性列表。大大的简化了代理的配置,减少了代理bean的定义,使用事务bean注入业务对象,而不是代理bean注入,更合乎事务逻辑。BeanNameAutoProxyCreator仍然需要开发人员除了定义业务bean外,还需要关心事务的定义,当然已经简单了很多。如果能实现一个BeanClassTypeAutoProxyCreator,为它指定一个可以代理的ClassType列表,那么在context中所有属于ClassType和其子类的bean都自动获得代理。
实现思路:
1.BeanNameAutoProxyCreator继承了AbstractAutoProxyCreator,去实现方法:
    protected abstract Object[] getAdvicesAndAdvisorsForBean(
Class beanClass, String beanName, TargetSource customTargetSource)
在BeanNameAutoProxyCreator中的实现是判断beanName 是存在于beanNames列表,如果能找到则Object[]不对空。否则返回null。
所以BeanClassTypeAutoProxyCreator也应该继承AbstractAutoProxyCreator。
getAdvicesAndAdvisorsForBean方法的实现可以参照BeanNameAutoProxyCreator方法的实现
2.BeanClassTypeAutoProxyCreator需要有一个进行代理的ClassType列表,在bean进行初始化后就在context中查找类型为ClassType列表中类型的所有beanName.从而获得一个beanNames列表。
获得beanNames列表后就可以像BeanNameAutoProxyCreator一样实现自动代理了。
3.要想获得当前context,我们可以实现ApplicationContextAware接口。让BeanClassTypeAutoProxyCreator的bean可以获得当前context.
4. 要在bean进行初始化动作,可以实现InitializingBean接口,实现afterPropertiesSet,在这个方法中在context中根据classType查找获得相关的beanName的列表。
5. 写一个空接口,里面没有任何方法。需要事务代理的类实现这个空接口。

这样,只需要把这个空接口的全类名作为BeanClassTypeAutoProxyCreator的classTypes参数值,然后所有需要代理的类都去实现这个接口就可以自动获得代理了。无再需要任何配置。这样就可以让程序员专心于业务逻辑的开发,而无需要去关心事务控制方法,就像是没有使用事务一样。

完整的实现类如下:
BeanClassTypeAutoProxyCreator.java
/**
* 根据类型自动代理Creator
*
*/
public class BeanClassTypeAutoProxyCreator extends AbstractAutoProxyCreator
implements ApplicationContextAware, InitializingBean {

/** Logger that is available to subclasses */
protected final Log logger = LogFactory.getLog(getClass());

/** ApplicationContext this object runs in */
private ApplicationContext applicationContext;

/** MessageSourceAccessor for easy message access */
private MessageSourceAccessor messageSourceAccessor;
   
/**被代理的bean别名列表**/
private List beanNames;
   
/**被代理的classType列表**/
private List classTypes;


//---------------------------------------------------------
//实现AbstractAutoProxyCreator的抽像方法
//---------------------------------------------------------
/**
* @see org.springframework.aop.framework.autoproxy.AbstractAutoProxyCreator#getAdvicesAndAdvisorsForBean(java.lang.Class,
*      java.lang.String, org.springframework.aop.TargetSource)
*/
protected Object[] getAdvicesAndAdvisorsForBean(Class beanClass,
String beanName, TargetSource targetSource) throws BeansException {
if (this.beanNames != null) {
if (this.beanNames.contains(beanName)) {
return PROXY_WITHOUT_ADDITIONAL_INTERCEPTORS;
}
}
return DO_NOT_PROXY;
}

//-------------------------------------------------------
//实现ApplicationContextAware接口方法
//-------------------------------------------------------
/**
* @see org.springframework.context.ApplicationContextAware#setApplicationContext(org.springframework.context.ApplicationContext)
*/
public void setApplicationContext(ApplicationContext context)
throws BeansException {
if (context == null && !isContextRequired()) {
// Reset internal context state.
this.applicationContext = null;
this.messageSourceAccessor = null;
} else if (this.applicationContext == null) {
// Initialize with passed-in context.
if (!requiredContextClass().isInstance(context)) {
throw new ApplicationContextException(
"Invalid application context: needs to be of type ["
+ requiredContextClass().getName() + "]");
}
this.applicationContext = context;
this.messageSourceAccessor = new MessageSourceAccessor(context);
initApplicationContext();
} else {
// Ignore reinitialization if same context passed in.
if (this.applicationContext != context) {
throw new ApplicationContextException(
"Cannot reinitialize with different application context: current one is ["
+ this.applicationContext
+ "], passed-in one is [" + context + "]");
}
}
}

/**
* Determine whether this application object needs to run in an
* ApplicationContext.
* <p>
* Default is "false". Can be overridden to enforce running in a context
* (i.e. to throw IllegalStateException on accessors if outside a context).
*
* @see #getApplicationContext
* @see #getMessageSourceAccessor
*/
protected boolean isContextRequired() {
return true;
}

/**
* Determine the context class that any context passed to
* <code>setApplicationContext</code> must be an instance of. Can be
* overridden in subclasses.
*
* @see #setApplicationContext
*/
protected Class requiredContextClass() {
return ApplicationContext.class;
}

/**
* Return the ApplicationContext instance used by this object.
*/
public final ApplicationContext getApplicationContext()
throws IllegalStateException {
if (this.applicationContext == null && isContextRequired()) {
throw new IllegalStateException(
"ApplicationObjectSupport instance [" + this
+ "] does not run in an ApplicationContext");
}
return applicationContext;
}

/**
* Return a MessageSourceAccessor for the application context used by this
* object, for easy message access.
*
* @throws IllegalStateException
*             if not running in an ApplicationContext
*/
protected final MessageSourceAccessor getMessageSourceAccessor()
throws IllegalStateException {
if (this.messageSourceAccessor == null && isContextRequired()) {
throw new IllegalStateException(
"ApplicationObjectSupport instance [" + this
+ "] does not run in an ApplicationContext");
}
return this.messageSourceAccessor;
}

public void setClassTypes(String[] classTypes) {
this.classTypes = Arrays.asList(classTypes);

}

/**
* Subclasses can override this for custom initialization behavior. Gets
* called by <code>setApplicationContext</code> after setting the context
* instance.
* <p>
* Note: Does </i>not</i> get called on reinitialization of the context but
* rather just on first initialization of this object's context reference.
*
* @throws ApplicationContextException
*             in case of initialization errors
* @throws BeansException
*             if thrown by ApplicationContext methods
* @see #setApplicationContext
*/
protected void initApplicationContext() throws BeansException {

}


//-----------------------------------
//实现InitializingBean接口方法
//-----------------------------------

    /**
     * 查找指定classType的beanName列表
     */
private List getBeanNames(String classType) {
List beanNameList = null;
try {
String[] beanName = this.getApplicationContext()
.getBeanNamesForType(Class.forName(classType), true, false);
if (beanName != null) {
beanNameList = Arrays.asList(beanName);
}
} catch (ClassNotFoundException ex) {
throw new IllegalArgumentException("Class not found: "
+ ex.getMessage());
}

return beanNameList;
}

/**
*
* @see org.springframework.beans.factory.InitializingBean#afterPropertiesSet()
*/
public void afterPropertiesSet() throws Exception {

if (classTypes != null && !classTypes.isEmpty()) {
beanNames = new ArrayList();
for (int i = 0; i < classTypes.size(); i++) {
String classType = (String) classTypes.get(i);
List aList = getBeanNames(classType);
beanNames.addAll(aList);
}
}
if (logger.isDebugEnabled()) {
for (int i = 0; i < beanNames.size(); i++) {

logger.debug("printBean:" + (String) beanNames.get(i));

}
}

}
}

3.使用BeanClassTypeAutoProxyCreator
3.1为了使用BeanClassTypeAutoProxyCreator,将为所有需要进行代理的类定一个接口。
package com.prs.application.ehld.biz.service;
public interface BaseService {

}

3.2 让需要代理的类实现或继承这个公共接口
package com.prs.application.ehld.sample.biz.service;
public interface SampleService extends BaseService {
       public void setUserInfoDAO(UserInfoDAO userInfoDAO);
       public void insertUserInfo(UserInfoDTO userInfo) throws BusinessServiceException;
}

3.3 配置事务代理
   <!—定义拦截器-->
<bean id="transactionInterceptor"
class="org.springframework.transaction.interceptor.TransactionInterceptor">
    <property name="transactionManager">
      <ref bean="transactionManager"/>
    </property>
        <property name="transactionAttributes">
            <props>
                <prop key="insert*">PROPAGATION_REQUIRED</prop>
                <prop key="update*">PROPAGATION_REQUIRED</prop>
                <prop key="save*">PROPAGATION_REQUIRED</prop>
                <prop key="find*">PROPAGATION_SUPPORTS,readOnly</prop>
                <prop key="get*">PROPAGATION_SUPPORTS,readOnly</prop>
                <prop key="*">PROPAGATION_SUPPORTS,readOnly</prop>
            </props>
        </property>
    </bean>

<!—定义类型自动代理创建器-->
<bean id="autoClassTypeProxyCreator"
class="com.prs.application.ehld.common.aotoproxy.BeanClassTypeAutoProxyCreator">
  <property name="interceptorNames">
      <value>transactionInterceptor</value>
   </property>
   <property name="classTypes">
   <list>
     <value>com.prs.application.ehld.biz.service.BaseService</value>
   </list>
   </property>
</bean>

  <!—定义事务bean-->
<bean id="sampleService"   class="com.prs.application.ehld.sample.biz.service.impl.SampleServiceImpl">
<property name="userInfoDAO"  ref="com.prs.application.ehld.sample.integration.dao.userInfoDAOImpl">
</property>
</bean>

效果:只需要定义BeanClassTypeAutoProxyCreator,把需要代理的类型BaseService作为classTypes的值。这样任何实现了BaseService接口的类都自动获得代理。使得程序员就像配置普通bean一样去配置一个需要事务代理的bean。使得程序员只需要去关心业务逻辑。而无需要去关注事务这些框架应该支持的事情。特别是当开发团队成员水平不一,或团队人员流动性大时,BeanClassTypeAutoProxyCreator就发挥了它的作用。一个好的架构设计应该对事务控制,异常处理,日志记录这些方面进行统一的规划和处理,才能保证系统的健壮性。
采用Spring框架进行项目开发,我们在获得它的IOC等好处,同时给我们增加了维护太多配置文件的负担。应该尽量减少bean的定义,更多采用嵌套bean定义。否则将加大项目后期的维护成本。作为一个架构设计者更是应该把通用性比较强的方面进行统一规划。

基于Spring 2.*使用tx标签配置的拦截器配置:
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xmlns:context="http://www.springframework.org/schema/context"
    xmlns:aop="http://www.springframework.org/schema/aop"
    xmlns:tx="http://www.springframework.org/schema/tx"
    xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.5.xsd http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-2.5.xsd http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-2.5.xsd http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-2.5.xsd">

    <context:annotation-config />
    <context:component-scan base-package="com.bluesky" />

    <bean id="sessionFactory" class="org.springframework.orm.hibernate3.LocalSessionFactoryBean">
        <property name="configLocation" value="classpath:hibernate.cfg.xml" />
        <property name="configurationClass" value="org.hibernate.cfg.AnnotationConfiguration" />
    </bean>

    <!-- 定义事务管理器(声明式的事务) -->
    <bean id="transactionManager"  class="org.springframework.orm.hibernate3.HibernateTransactionManager">
        <property name="sessionFactory" ref="sessionFactory" />
    </bean>

    <tx:advice id="txAdvice" transaction-manager="transactionManager">
        <tx:attributes>
            <tx:method name="*" propagation="REQUIRED" />
        </tx:attributes>
    </tx:advice>
  
    <aop:config>
        <aop:pointcut id="interceptorPointCuts"
           expression="execution(* com.bluesky.spring.dao.*.*(..))" />
        <aop:advisor advice-ref="txAdvice" pointcut-ref="interceptorPointCuts" />      
    </aop:config>    
</beans>

Spring 3.*推荐的全注解

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xmlns:context="http://www.springframework.org/schema/context"
    xmlns:aop="http://www.springframework.org/schema/aop"
    xmlns:tx="http://www.springframework.org/schema/tx"
    xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.5.xsd  http://www.springframework.org/schema/context
http://www.springframework.org/schema/context/spring-context-2.5.xsd http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-2.5.xsd http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-2.5.xsd">

    <context:annotation-config />
    <context:component-scan base-package="com.bluesky" />

    <tx:annotation-driven transaction-manager="transactionManager"/>

    <bean id="sessionFactory"        class="org.springframework.orm.hibernate3.LocalSessionFactoryBean">
       <property name="configLocation" value="classpath:hibernate.cfg.xml" />
        <property name="configurationClass" value="org.hibernate.cfg.AnnotationConfiguration" />
    </bean>

    <!-- 定义事务管理器(声明式的事务) -->
    <bean id="transactionManager"     class="org.springframework.orm.hibernate3.HibernateTransactionManager">
        <property name="sessionFactory" ref="sessionFactory" />
    </bean>
  
</beans>

分享到:
评论
发表评论

文章已被作者锁定,不允许评论。

相关推荐

    spring架构详解 spring架构详解

    Spring的AOP模块提供了在运行时对代码进行横切关注点(如日志、事务管理)的能力。它通过代理模式实现,可以将切面逻辑与业务代码分离,提高代码的复用性和模块化。 5. **设计模式** Spring框架广泛运用了多种...

    Spring技术内幕:深入解析Spring架构与设计原理(第2版) .pdf

    《Spring技术内幕:深入解析Spring架构与设计原理(第2版)》这本书主要聚焦于Spring框架的核心架构和技术细节,帮助读者全面理解Spring的工作机制、设计理念以及实现方式。下面将根据书名及其描述来展开相关知识点。 ...

    Spring技术内幕:深入解析Spring架构与设计原理

    《Spring技术内幕:深入解析Spring架构与设计原理》是一本由计文柯编著的书籍,专注于揭示Spring框架的核心机制和设计理念。这本书是为那些希望深入理解Spring如何工作,以及为何如此高效和灵活的开发者而准备的。...

    spring技术内幕第2版深入解析spring架构与设计原理

    在深入解析Spring技术内幕第2版中,会详细探讨Spring框架的核心架构与设计原理,Spring作为一个轻量级的Java平台,提供了全面的编程和配置模型,是企业级Java应用程序开发中广泛使用的技术之一。 Spring的核心特性...

    spring mvc 事务配置+异常处理

    接下来,我们将深入探讨Spring MVC中的事务配置和异常处理。 **1. Spring MVC 事务配置** 在Spring中,事务管理主要依赖于Spring的`PlatformTransactionManager`接口,它是所有事务管理器的基类。Spring提供了多种...

    SPRING技术内幕:深入解析SPRING架构与设计原理

    《SPRING技术内幕:深入解析SPRING架构与设计原理》这本书是Java开发领域的一部重量级作品,由具有丰富开发经验的专家撰写,受到了Java开发者社区和Spring开发者社区的高度推崇。书中深入剖析了Spring框架的核心架构...

    SPRING技术内幕:深入解析SPRING架构与设计原理.pdf 下载

    根据提供的标题和描述,我们可以深入探讨Spring框架的核心架构与设计原理。...对于希望深入了解Spring架构与设计原理的学习者来说,《SPRING技术内幕:深入解析SPRING架构与设计原理》这本书是一个非常宝贵的资源。

    SPRING技术内幕+深入解析SPRING架构与设计 55M(下载地址)

    ### Spring技术内幕与深入解析Spring架构与设计 #### 书籍概述 本书《Spring技术内幕+深入解析Spring架构与设计》是一本专为Spring框架开发者所撰写的深度技术指南。作者凭借超过十年的Java开发经验,从Spring 3.0...

    Spring技术内幕:深入解析Spring架构与设计原理(第2版)+.pdf

    根据提供的文件标题“Spring技术内幕:深入解析Spring架构与设计原理(第2版)”和描述,我们可以了解到这是一本深入探讨Spring框架内部架构和技术细节的专业书籍。虽然标签中出现了“oracle”,但从标题和描述来看,...

    spring技术内幕-深入解析spring架构与设计原理

    《Spring技术内幕——深入解析Spring架构与设计原理》是一本深度剖析Spring框架核心机制与设计理念的专业书籍。本书旨在帮助读者全面理解Spring的内部工作原理,从而更好地应用和优化Spring框架在实际开发中的使用。...

    Spring技术内幕:深入解析Spring架构与设计原理(第2版).pdf

    根据提供的文件标题“Spring技术内幕:深入解析Spring架构与设计原理(第2版)”,我们可以推测这本书主要聚焦于Spring框架的核心架构与设计理念。虽然描述部分为空白,但是结合标题和标签“spring”,我们可以深入...

    Spring事务配置的五种方式

    ### Spring事务配置的五种方式详解 #### 一、引言 在企业级应用开发中,事务处理是非常重要的一部分,特别是在涉及多个数据操作时。Spring框架提供了强大的事务管理功能,支持编程式和声明式两种事务处理方式。其中...

    SPRING技术内幕:深入解析SPRING架构与设计原理.zip

    《SPRING技术内幕:深入解析SPRING架构与设计原理》这本书深入探讨了Spring框架的核心机制和设计理念,旨在帮助读者理解并掌握Spring的精髓。Spring作为Java企业级应用开发的重要工具,其灵活性、可扩展性和模块化的...

    Spring技术内幕:深入解析Spring架构与设计原理(第2版).pdf

    总而言之,《Spring技术内幕:深入解析Spring架构与设计原理(第2版)》这本书通过深入浅出的方式讲解了Spring框架的核心原理,不仅涵盖了其核心的IoC容器、AOP、事务管理、Spring MVC等组件,还探讨了Spring在数据...

    Spring技术内幕 - 深入解析Spring架构与设计原理.rar

    《Spring技术内幕 - 深入解析Spring架构与设计原理》这本书是IT领域的经典之作,专为想要深入了解Spring框架的开发者而准备。Spring作为Java领域最广泛应用的轻量级框架,其设计理念和实现机制一直是广大程序员关注...

    深入解析Spring架构与设计原理.pdf

    《深入解析Spring架构与设计原理》是一本专为IT专业人士准备的深度学习Spring框架的书籍。Spring作为Java领域最广泛使用的轻量级框架之一,它的设计理念、核心组件以及实际应用都值得开发者深入研究。以下是对Spring...

    SPRING技术内幕:深入解析SPRING架构与设计原理_spring_

    《SPRING技术内幕:深入解析SPRING架构与设计原理》这本书深入探讨了Spring框架的核心机制、设计理念以及在实际开发中的应用。Spring作为Java领域最流行的轻量级框架,它的广泛应用和强大功能使得深入理解其工作原理...

    spring架构项目案例

    总结来说,"spring架构项目案例"是一个适合初学者的实践教程,涵盖了Spring 2.0的关键特性,包括依赖注入、AOP、Spring MVC、JDBC支持、事务管理和ORM集成。通过学习和实践这个项目,开发者可以掌握Spring的核心概念...

Global site tag (gtag.js) - Google Analytics