`
lovnet
  • 浏览: 6670524 次
  • 性别: Icon_minigender_1
  • 来自: 武汉
文章分类
社区版块
存档分类
最新评论

Spring高级程序设计 16 事务管理

 
阅读更多
2分析事务属性
众所周知的ACID属性:
原子性(atomicity)、一致性(consistency)、隔离性(isolation)以及持久性(durability)。我们无法控制一致性、原子性以及持久性,但可以控制超时,设置事务的只读性以指定隔离级别。
Spring在TransactionDefinition接口封装了所有这些设置。


探索TransactionDefinition接口:
  1. packageorg.springframework.transaction;
  2. publicinterfaceTransactionDefinition {
  3. intgetPropagationBehavior();
  4. intgetIsolationLevel();
  5. intgetTimeout();
  6. booleanisReadOnly();
  7. String getName();
  8. }


getTimeout:返回一个事务必须完成的时间限制。

isReadOnly:表示事务是否只读。

getIsolationLevel:他对其他事务所看到的数据变化进行控制。
事务隔离级别:
隔离级别 说明
ISOLATION_DEFAULT 默认级别(对大多数数据库来说就是ISOLATION_READ_COMMITTED)
ISOLATION_READ_UNCOMMITTED 最低的隔离级别。事实上我们不应该隔离级别,因为在事务完成前,其他事务可以看到该事务所修改的数据。而在其他事务提交前,该事务也可以看到其他事务所做的修改。
ISOLATION_READ_COMMITTED 大多数数据库的默认级别。在事务完成前,其他事务无法看到该事务所修改的数据。遗憾的是,在该事务提交后,你就可以查看其他事务插入活更新的数据。这意味着在事务的不同点上,如果其他事务修改数据,你会看到不同的数据。
ISOLATION_REPEATABLE_READ 该隔离级别确保如果在事务中查询了某个数据集,你至少还能再次查询到相同的数据集,即使其他事务修改了所查询的数据。然而如果其他事务插入了新数据,你就可以查询到该新插入的数据。
ISOLATION_SERIALIZABLE 代价最大、可靠性最高的隔离级别,所有的事务都是俺顺序一个接一个的执行。

getPropagationBehavior:指定了当代码请求一个新的事务时Spring所做的事情。
传播行为指:
传播行为 说明
PROPAGATION_REQUIRED 当前如果有事务,Spring就会使用该事务;否则会开始一个新事务。
PROPAGATION_SUPPORTS 当前如果有事务,Spring就会使用该事务;否则不会开启一个新事务。
PROPAGATION_MANDATORY 当前如果有事务,Spring就会使用该事务;否则会抛出异常。
PROPAGATION_REQUIRES_NEW Spring总会开始一个新事务。如果当前有事务,则该事务挂起。
PROPAGATION_NOT_SUPPORTED Spring不会执行事务中的代码。代码总是在非事务环境下执行,如果当期有事务,则该事务挂起。
PROPAGATION_NEVER 即使当前有事务,Spring也会在飞事务环境下执行。如果当前有事务,则抛出异常。
PROPAGATION_NESTED 如果当前有事务,则在嵌套事务中执行。如果没有,那么执行情况与PROPAGATION_REQUIRED一样。





使用TransactionStatus接口:
  1. packageorg.springframework.transaction;
  2. publicinterfaceTransactionStatusextendsSavepointManager {
  3. booleanisNewTransaction();
  4. booleanhasSavepoint();
  5. voidsetRollbackOnly();
  6. booleanisRollbackOnly();
  7. booleanisCompleted();
  8. }

setRollbackOnly:将一个事务表示为不可提交的。




PlatformTransactionManager的实现:
使用TransactionDefinition和TransactionStatus接口,创建并管理事务。

DataSourceTransactionManager控制着从DataSource中获得的JDBC Connection上的事务执行;
HibernateTransactionManager控制着Hibernate session上的事务执行;
JdoTransactionManager管理着JDO事务;
JtaTransactionManager将事务管理委托给JTA。

例如:
JDBC:
  1. <!-- 声明事务处理器 -->
  2. <bean id="transactionManager"
  3. class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
  4. <property name="dataSource"ref="dataSource"></property>
  5. </bean>
  6. <!-- 声明事务通知 -->
  7. <tx:advice id="bookShopTx"
  8. transaction-manager="transactionManager">
  9. <tx:attributes>
  10. <tx:method name="purchase"
  11. propagation="REQUIRES_NEW"
  12. isolation="READ_COMMITTED"
  13. rollback-for="java.lang.ArithmeticException"/>
  14. </tx:attributes>
  15. </tx:advice>
  16. <!-- 声明事务通知需要通知哪些类的那些方法, 即: 那些方法受事务管理 -->
  17. <aop:config>
  18. <!-- 声明切入点 -->
  19. <aop:pointcut expression="execution(* cn.partner4java.spring.transaction.BookShopService.*(..))"
  20. id="txPointCut"/>
  21. <!-- 把切入点和事务通知联系起来: 既声明一个增强器 -->
  22. <aop:advisor advice-ref="bookShopTx"pointcut-ref="txPointCut"/>
  23. </aop:config>

Hibernate:
  1. <bean id="sessionFactory"
  2. class="org.springframework.orm.hibernate3.LocalSessionFactoryBean">
  3. <property name="configLocation"value="classpath:hibernate.cfg.xml"></property>
  4. <property name="dataSource"ref="dataSource"></property>
  5. </bean>
  6. <bean id="transactionManager"
  7. class="org.springframework.orm.hibernate3.HibernateTransactionManager">
  8. <property name="sessionFactory"ref="sessionFactory"></property>
  9. </bean>
  10. <!-- 事务通知 -->
  11. <tx:advice id="txAdvice"transaction-manager="transactionManager">
  12. <tx:attributes>
  13. <tx:method name="new*"propagation="REQUIRED"isolation="DEFAULT"/>
  14. <tx:method name="save*"propagation="REQUIRED"isolation="DEFAULT"/>
  15. <tx:method name="update*"propagation="REQUIRED"isolation="DEFAULT"/>
  16. <tx:method name="delete*"propagation="REQUIRED"isolation="DEFAULT"/>
  17. <tx:method name="bulk*"propagation="REQUIRED"isolation="DEFAULT"/>
  18. <tx:method name="load*"propagation="REQUIRED"isolation="DEFAULT"read-only="true"/>
  19. <tx:method name="get*"propagation="REQUIRED"isolation="DEFAULT"read-only="true"/>
  20. <tx:method name="query*"propagation="REQUIRED"isolation="DEFAULT"read-only="true"/>
  21. <tx:method name="find*"propagation="REQUIRED"isolation="DEFAULT"read-only="true"/>
  22. <tx:method name="is*"propagation="REQUIRED"isolation="DEFAULT"read-only="true"/>
  23. <tx:method name="*"propagation="SUPPORTS"isolation="DEFAULT"/>
  24. </tx:attributes>
  25. </tx:advice>
  26. <aop:config>
  27. <aop:advisor pointcut="execution(* *..*service*.*(..))"advice-ref="txAdvice"/>
  28. </aop:config>
  29. <context:component-scan base-package="com.bytter"></context:component-scan>
  30. <tx:annotation-driven/>

JPA:
  1. <bean id="entityManagerFactory"class="org.springframework.orm.jpa.LocalContainerEntityManagerFactoryBean">
  2. <property name="dataSource"ref="dataSource"/>
  3. <property name="persistenceXmlLocation"value="classpath:META-INF/persistence.xml"/>
  4. <property name="loadTimeWeaver">
  5. <beanclass="org.springframework.instrument.classloading.InstrumentationLoadTimeWeaver"/>
  6. </property>
  7. </bean>
  8. <bean id="transactionManager"class="org.springframework.orm.jpa.JpaTransactionManager">
  9. <property name="entityManagerFactory"ref="entityManagerFactory"/>
  10. </bean>
  11. <tx:annotation-driven transaction-manager="transactionManager"/>




3对一个事务管理示例的探索
使用事务操作方式有3种基本方式:
可以使用声明式事务,只需声明某个方法需要事务就行了;
可以使用源码级的元数据来说明某个方法需要一个事务;
还可以用编写事务代码的方式来实现。






6AOP事务管理

1、使用基于注解的AOP事务管理
<tx:annotation-driven transaction-manager="transactionManager"/>

<aop:aspectj-autoproxy />


探索tx:annotation-driven标签:
<tx:annotation-driven/>标签是注解驱动的事务管理支持的核心。

<tx:annotation-driven/>标签的属性:
transaction-manager:指定到现有的PlatformTransactionManager bean的引用,通知会使用该引用。default="transactionManager"
mode:指定Spring事务管理框架创建通知bean的方式。可用的值有proxy和aspectj。前者是默认值,表示通知对象是个JDK代理;后者表示Spring AOP会使用AspectJ创建代理。
order:指定创建的切面的顺序。只要目标对象有多个通知就可以使用该属性。
proxy-target-class:该属性如果为true就表示你想要代理目标类而不是bean所实现的所有接口。default="false"

探索@Transactional注解:
你可以指定传播、隔离级别、超时以及允许和不允许的异常。
@Transactional注解的属性:
propagation:指定事务定义中使用的传播
isolation:设定事务的隔离级别
timeout:指定事务的超市(秒)
readOnly:指定事务的超时
noRollbackFor:目标方法可抛出的异常所构成的数组,但通知仍会提交事务
rollbackFor:异常所构成的数组,如果目标方法抛出了这些异常,通知就会回滚事务



基于注解的事务管理小结:
如果定义在类上,那么所有的方法都使用相同的方式,有些read就会抱怨给太多的东西了。
如果在每个方法上都定义注解,那么就会很麻烦。
(可以使用XML AOP事务管理能更好的处理这种情况)







2、使用XML AOP事务管理
<tx:advice/>标签,该标签会创建一个事务处理通知。
  1. <tx:advice id="txAdvice"transaction-manager="transactionManager">
  2. <tx:attributes>
  3. <tx:method name="bulk*"propagation="REQUIRED"isolation="DEFAULT"/>
  4. <tx:method name="load*"propagation="REQUIRED"isolation="DEFAULT"read-only="true"/>
  5. </tx:attributes>
  6. </tx:advice>
  7. <aop:config>
  8. <aop:advisor pointcut="execution(* *..*Service*.*(..))"advice-ref="txAdvice"/>
  9. </aop:config>
  10. <aop:config>
  11. <aop:pointcut id="allServiceMethods"
  12. expression="execution(* com.apress.prospring2.ch16.services.*.*(..))"/>
  13. <aop:advisor advice-ref="defaultTransactionAdvice"
  14. pointcut-ref="allServiceMethods"/>
  15. </aop:config>
  16. <tx:advice id="defaultTransactionAdvice"transaction-manager="transactionManager">
  17. <tx:attributes>
  18. <tx:method
  19. name="*"
  20. isolation="DEFAULT"
  21. propagation="REQUIRED"
  22. no-rollback-for="java.lang.RuntimeException"
  23. timeout="100"/>
  24. <tx:method
  25. name="get*"
  26. read-only="true"/>
  27. </tx:attributes>
  28. </tx:advice>








3、tx:advice标签简介
id是该advice bean的标识,而transaction-manager则必须引用一个PlatformTransactionManager bean。
还可以通过<tx:attributes>标签定制<tx:advice>标签所创建的通知的行为。

<tx:method/>标签的属性:

name:方法名的匹配模式,通知根据该模式寻找匹配的方法。
propagation:设定事务定义所用的传播级别。
isolation:设置事务的隔离级别。
timeout:指定事务的超时(秒)。
read-only:该属性为true指示事务是只读的
no-rollback-for:以逗号分隔的异常类的列表,目标方法可以跑出这些异常而不会导致通知执行回滚
rollback-for:以逗号分隔的异常类的列表,当目标方法跑出这些异常时会导致通知执行回滚。默认情况下,该列表为空,因此不在no-rollback-for列表中的任何运行时异常都会导致回滚。






8实现你自己的事务同步

将介绍如何实现你自己的事务同步,只要是活动的事务状态发生变化就会收到TransactionSynchronizationManager的回调。

书中的demo:
使用TransactionSynchronizationManager注册了TransactionSynchronization回调,同时MyTransactionSynchronizationAdapter会根据事务的完成状态去调用MySession.beginTransaction()、MySession.commit()或MySession.rollback()方法。


模拟一个session类:
  1. packagecn.partner4java.myptm;
  2. importjava.io.Serializable;
  3. /**
  4. * 模拟一个session类
  5. * @author partner4java
  6. *
  7. */
  8. publicclassMySession {
  9. /** 用来标识一个session */
  10. privateLong sessionId;
  11. publicvoidsave(Serializable entity){
  12. System.out.println(sessionId +":save");
  13. }
  14. publicvoidbeginTransaction(){
  15. System.out.println(sessionId +":beginTransaction");
  16. }
  17. publicvoidcommit(){
  18. System.out.println(sessionId +":commit");
  19. }
  20. publicvoidrollback(){
  21. System.out.println(sessionId +":rollback");
  22. }
  23. publicLong getSessionId() {
  24. returnsessionId;
  25. }
  26. publicvoidsetSessionId(Long sessionId) {
  27. this.sessionId = sessionId;
  28. }
  29. @Override
  30. publicString toString() {
  31. return"MySession [sessionId="+ sessionId +"]";
  32. }
  33. }

简单模拟SessionFactory:
  1. packagecn.partner4java.myptm;
  2. importorg.springframework.transaction.support.TransactionSynchronization;
  3. importorg.springframework.transaction.support.TransactionSynchronizationManager;
  4. /**
  5. * 简单模拟SessionFactory<br/>
  6. * 通判传递的类都为MySessionFactory而不是MySession,通过MySessionFactory获得当前线程的MySession或者开启一个新的MySession
  7. * @author partner4java
  8. *
  9. */
  10. publicclassMySessionFactory {
  11. /**
  12. * 如果当前线程存在MySession,就使用该MySession,否者开启一个新的MySession
  13. * @return
  14. */
  15. publicMySession getSession(){
  16. //传入this,是因为,我们以当前factory类作为键保存的MySession
  17. if(TransactionSynchronizationManager.hasResource(this)){
  18. returngetCurrentSession();
  19. }else{
  20. returnopenSession();
  21. }
  22. }
  23. /**
  24. * 开启一个新MySession
  25. * @return
  26. */
  27. privateMySession openSession() {
  28. MySession mySession =newMySession();
  29. mySession.setSessionId(System.currentTimeMillis());
  30. //注册进当前线程管理一个Synchronization
  31. TransactionSynchronization transactionSynchronization =newMyTransactionSynchronizationAdapter(this);
  32. TransactionSynchronizationManager.registerSynchronization(transactionSynchronization);
  33. //绑定新开启的一个MySession进当前线程事务管理器
  34. TransactionSynchronizationManager.bindResource(this, mySession);
  35. returnmySession;
  36. }
  37. /**
  38. * 获取当前线程的MySession
  39. * @return
  40. */
  41. privateMySession getCurrentSession() {
  42. MySession mySession = (MySession) TransactionSynchronizationManager.getResource(this);
  43. returnmySession;
  44. }
  45. }

核心事务同步适配器:
  1. packagecn.partner4java.myptm;
  2. importorg.springframework.transaction.support.TransactionSynchronizationAdapter;
  3. importorg.springframework.transaction.support.TransactionSynchronizationManager;
  4. /**
  5. * 核心事务同步适配器<br/>
  6. * 当方法上面定义了@Transactional注解,那么当每次状态发生时就会调用本同步适配器
  7. * for transaction synchronization callbacks
  8. * @author partner4java
  9. *
  10. */
  11. publicclassMyTransactionSynchronizationAdapterextends
  12. TransactionSynchronizationAdapter {
  13. privateMySessionFactory mySessionFactory;
  14. publicMyTransactionSynchronizationAdapter(MySessionFactory mySessionFactory) {
  15. this.mySessionFactory = mySessionFactory;
  16. }
  17. @Override
  18. publicvoidbeforeCommit(booleanreadOnly) {
  19. //readOnly标识是否是一个只读线程
  20. if(!readOnly){
  21. MySession mySession = (MySession) TransactionSynchronizationManager.getResource(mySessionFactory);
  22. mySession.beginTransaction();
  23. }
  24. }
  25. @Override
  26. publicvoidafterCompletion(intstatus) {
  27. MySession mySession = (MySession) TransactionSynchronizationManager.getResource(mySessionFactory);
  28. if(STATUS_COMMITTED == status) {
  29. mySession.commit();
  30. }
  31. //当然,你还可以定义回滚方法
  32. }
  33. }

调用起的DAO:
  1. packagecn.partner4java.dao;
  2. publicinterfaceHelloDao {
  3. publicvoidsaveHello();
  4. }

  1. packagecn.partner4java.dao;
  2. importorg.springframework.jdbc.core.support.JdbcDaoSupport;
  3. importorg.springframework.transaction.annotation.Transactional;
  4. importcn.partner4java.myptm.MySessionFactory;
  5. /**
  6. * 一个hello world dao,起到模拟调用自定义事务同步的作用
  7. * @author partner4java
  8. *
  9. */
  10. publicclassHelloDaoImplextendsJdbcDaoSupportimplementsHelloDao {
  11. privateMySessionFactory mySessionFactory;
  12. publicvoidsetMySessionFactory(MySessionFactory mySessionFactory) {
  13. this.mySessionFactory = mySessionFactory;
  14. }
  15. @Transactional
  16. publicvoidsaveHello(){
  17. mySessionFactory.getSession().save(null);
  18. this.getJdbcTemplate().execute("select * from user");
  19. }
  20. }


配置文件:
  1. <?xml version="1.0"encoding="UTF-8"?>
  2. <beans xmlns="http://www.springframework.org/schema/beans"
  3. xmlns:aop="http://www.springframework.org/schema/aop"
  4. xmlns:tx="http://www.springframework.org/schema/tx"
  5. xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  6. xsi:schemaLocation="
  7. http://www.springframework.org/schema/beans
  8. http://www.springframework.org/schema/beans/spring-beans.xsd
  9. http://www.springframework.org/schema/tx
  10. http://www.springframework.org/schema/tx/spring-tx.xsd
  11. http://www.springframework.org/schema/aop
  12. http://www.springframework.org/schema/aop/spring-aop.xsd">
  13. <bean id="dataSource"class="org.springframework.jdbc.datasource.DriverManagerDataSource"destroy-method="close">
  14. <property name="driverClassName"value="com.mysql.jdbc.Driver"/>
  15. <property name="url"value="jdbc:mysql://localhost:3306/springdb"/>
  16. <property name="username"value="root"/>
  17. <property name="password"value="123456"/>
  18. </bean>
  19. <bean id="transactionManager"class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
  20. <property name="dataSource"ref="dataSource"/>
  21. </bean>
  22. <tx:annotation-driven transaction-manager="transactionManager"/>
  23. <aop:aspectj-autoproxy />
  24. <bean id="mySessionFactory"class="cn.partner4java.myptm.MySessionFactory"/>
  25. <bean id="helloDao"class="cn.partner4java.dao.HelloDaoImpl">
  26. <property name="dataSource"ref="dataSource"/>
  27. <property name="mySessionFactory"ref="mySessionFactory"></property>
  28. </bean>
  29. </beans>


测试:
  1. ApplicationContext ac =newClassPathXmlApplicationContext("/META-INF/spring/myptm.xml");
  2. HelloDao helloDao = (HelloDao) ac.getBean("helloDao");
  3. helloDao.saveHello();
  4. // 后台打印:
  5. // 1322395163008:save
  6. // 1322395163008:beginTransaction
  7. // 1322395163008:commit

总结:有两个核心的Spring类支持了这个功能,TransactionSynchronization接口,TransactionSynchronizationManager类。
TransactionSynchronizationManager负责管理当前线程在资源,资源可以主动绑定到TransactionSynchronizationManager中。
TransactionSynchronization提供了同步调用,当方法上面定义了@Transactional注解,那么当每次状态发生时就会调用本同步适配器。

PlatformTransactionManager的各种实现也是借助了上面这两个类,你可以查阅一下源码。所以,我们自然而然的也可以自己实现一个PlatformTransactionManager,来管理真正的sessionFactory,然后像其他实现一样,交给Spring,然后再给他声明事务。
分享到:
评论

相关推荐

    spring高级程序设计

    Spring是一个完整的J2EE框架和解决方案,完整并且模块化,你可以用的他的全部也可以只用他的一部分特性,Spring 包含 IoC, AOP, 事务处理,ORM, 当然也包括一个简单的MVC框架。作为最强大、应用最广泛的企业级Java...

    Spring事务管理高级应用难点剖析(3)

    绍Spring事务管理高级应用难点剖析(3)

    Spring事务管理高级应用难点剖析(4)

    绍Spring事务管理高级应用难点剖析

    Java Web程序设计教程

    程序设计教程.pdf&gt;&gt;人民邮电出版社的教程哦,所以,好书,你懂的!! 第1章web应用开发简介 1 1.1何为web应用 1 1.1.1web的概念及发展 1 1.1.2web应用程序 2 1.2使用java开发web应用 3 1.2.1面向对象的编程语言...

    Spring事务管理高级应用难点剖析(2)

    绍Spring事务管理高级应用难点剖析(2)

    Spring攻略(第二版 中文高清版).part1

    第2章 高级Spring IoC容器 57 2.1 调用静态工厂方法创建Bean 57 2.1.1 问题 57 2.1.2 解决方案 57 2.1.3 工作原理 57 2.2 调用一个实例工厂方法创建Bean 58 2.2.1 问题 58 2.2.2 解决方案 59 2.2.3...

    Spring.3.x企业应用开发实战(完整版).part2

    10.5.2 Hibernate+Spring JDBC混合框架的事务管理 10.6 特殊方法成漏网之鱼 10.6.1 哪些方法不能实施Spring AOP事务 10.6.2 事务增强遗漏实例 10.7 数据连接泄漏 10.7.1 底层连接资源的访问问题 10.7.2 Spring JDBC...

    Spring AOP源码深度解析:掌握Java高级编程核心技术

    Spring AOP(面向切面编程)是Java高级编程中的重要组成部分,它允许程序员以声明的方式处理关注点(例如日志、事务管理等),而不是通过硬编码。本文深入分析了Spring AOP的实现机制,让读者能够更好地理解和应用这...

    Spring攻略(第二版 中文高清版).part2

    第2章 高级Spring IoC容器 57 2.1 调用静态工厂方法创建Bean 57 2.1.1 问题 57 2.1.2 解决方案 57 2.1.3 工作原理 57 2.2 调用一个实例工厂方法创建Bean 58 2.2.1 问题 58 2.2.2 解决方案 59 2.2.3...

    Spring in Action(第2版)中文版

    6.1.2理解spring对事务管理的支持 6.2选择事务管理器 6.2.1jdbc事务 6.2.2hibernate事务 6.2.3jpa事务 6.2.4jdo事务 6.2.5jta事务 6.3在spring中编写事务 6.4声明式事务 6.4.1定义事务参数 6.4.2代理事务 ...

    Spring in Action(第二版 中文高清版).part2

    6.1.2 理解Spring对事务管理的支持 6.2 选择事务管理器 6.2.1 JDBC事务 6.2.2 Hibernate事务 6.2.3 JPA事务 6.2.4 JDO事务 6.2.5 JTA事务 6.3 在Spring中编写事务 6.4 声明式事务 6.4.1 定义事务参数 ...

    Spring in Action(第二版 中文高清版).part1

    6.1.2 理解Spring对事务管理的支持 6.2 选择事务管理器 6.2.1 JDBC事务 6.2.2 Hibernate事务 6.2.3 JPA事务 6.2.4 JDO事务 6.2.5 JTA事务 6.3 在Spring中编写事务 6.4 声明式事务 6.4.1 定义事务参数 ...

    Spring3.x企业应用开发实战(完整版) part1

    10.5.2 Hibernate+Spring JDBC混合框架的事务管理 10.6 特殊方法成漏网之鱼 10.6.1 哪些方法不能实施Spring AOP事务 10.6.2 事务增强遗漏实例 10.7 数据连接泄漏 10.7.1 底层连接资源的访问问题 10.7.2 Spring JDBC...

    springmybatis

    MyBatis是支持普通SQL查询,存储过程和高级映射的优秀持久层框架。MyBatis消除了几乎所有的JDBC代码和参数的手工设置以及结果集的检索。MyBatis使用简单的XML或注解用于配置和原始映射,将接口和Java的POJOs(Plan ...

    JAVA超全面试突击包-答案讲义

    内容包括:Spring、SprngBoot、SpringCloud、Redis、MySQL、MyBatis、JVM、多线程和高并发、设计模式等 Spring框架:包括Spring的核心概念,如依赖注入和面向切面编程 Spring Boot:包括Spring Boot的基础知识,如...

    java web开发技术大全

    JSP+Servlet+Struts+Hibernate+Spring+Ajax》重点讲解了Struts 2、Speing和HIbernate框架的基础知识和高级技术,如Sruts 2中的*、类型转换、国际化和标签等,HIbe rna{e的会话、0/R映射和事务管理等,Spring中的...

    java web技术开发大全(最全最新)

    JSP+Servlet+Struts+Hibernate+Spring+Ajax》重点讲解了Struts 2、Speing和HIbernate框架的基础知识和高级技术,如Sruts 2中的*、类型转换、国际化和标签等,HIbe rna{e的会话、0/R映射和事务管理等,Spring中的...

    Java测试新技术TestNG和高级概念.part1

    展示了如何测试应用程序元素,包括Java EE APls、数据库、Web页面和XML文件。 展示了高级技术:测试部分失败、工厂、依赖关系测试、远程调用、基于集群的测试服务器群等。 介绍了在Eclipse和IDE中安装TestNG插件。 ...

    积分管理系统java源码-knowledge:这是我的知识,包括我所有已知的

    IOC容器设计原理及高级特性 AOP设计原理 FactoryBean和BeanFactory Spring事务处理机制 Spring JDBC Spring MVC九大组件 手动实现Spring MVC Spring5新特性 Mybatis 代码自动生成器 mybatis关联查询和嵌套查询 缓存...

    ActiveMQ消息服务器.rar

    Spring支持,以便ActiveMQ可以轻松嵌入到Spring应用程序中,并使用Spring的XML配置机制进行配置。 专为高性能集群,客户端 - 服务器,基于对等的通信而设计。 CXF和Axis支持,以便ActiveMQ可以轻松地放入这些Web服务...

Global site tag (gtag.js) - Google Analytics