`
a137268431
  • 浏览: 157766 次
文章分类
社区版块
存档分类
最新评论

Spring3与hibernate4集中式声明事务管理与注解式事务管理

 
阅读更多

Email：137268431@qq.com

Blog：http://blog.csdn.net/LzwGlory


概述:

还像往常一样先了解下基础知识:
Hibernate是一个开源的ORM框架，能自动为对象生成相应SQL并透明的持久化对象到数据库，我们首先来了解一下什么是“ORM”。
ORM全称对象关系映射（Object/Relation Mapping），指将Java对象状态自动映射到关系数据库中的数据上，从而提供透明化的持久化支持，即把一种形式转化为另一种形式。
对象与关系数据库之间是不匹配，我们把这种不匹配称为阻抗失配，主要表现在：
  • 关系数据库首先不支持面向对象技术，如继承、多态；
  • 关系数据库是由表来存放数据，而面向对象使用对象来存放状态；
  • 如何将对象透明的持久化到关系数据库表中；
如果一个对象存在横跨多个表的数据，应该有一种策略来对象建模和映射。
其中这些阻抗失配只是其中的一小部分，比如还有如何将SQL集合函数结果集映射到对象，如何在对象中处理主键等。ORM框架就是用来解决这种阻抗失配，提供关系数据库的对象化支持。
目前已经有许多ORM框架产生，如Hibernate、JDO、JPA、iBATIS等等，这些ORM框架各有特色，Spring对这些ORM框架提供了很好的支持。

集中式声明事务管理源码下载注解式事务管理源码下载结合原文更容易理解

下面来看具体配置:


集中式声明事务管理：


pom.xml


1)先来看jar含义

虽然只加了这么几个包,但是来看看maven帮我们添加的最终依赖包，从这就可以看出maven管理项目的好处:
虽然不是每个包都被用到但是这样就会减少管理jar的繁琐，况且也可以手动的删除这些jar,maven还是很不错吧！
[INFO] antlr:antlr:jar:2.7.7:compile
一个语言转换工具，Hibernate利用它实现 HQL 到 SQL 的转换
[INFO] aopalliance:aopalliance:jar:1.0:compile
包含了针对面向切面的接口。
[INFO] com.alibaba:druid:jar:0.2.25:compile
阿里巴巴开发的一个高效的数据库连接池：druid。
[INFO] commons-logging:commons-logging:jar:1.1.1:compile
是使用Spring-core.jar的必备包
[INFO] dom4j:dom4j:jar:1.6.1:compile
dom4j XML 解析器
[INFO] junit:junit:jar:4.11:compile
测试工具
[INFO] mysql:mysql-connector-java:jar:5.1.26:compile
连接mysql插件
[INFO] org.aspectj:aspectjweaver:jar:1.7.3:compile
切面用到的包，也就是AOP
[INFO] org.hamcrest:hamcrest-core:jar:1.3:compile
是junit的依赖包，在4.11这个版本里，不包含这个包，4.8版本就不需要这个包
[INFO] org.hibernate:hibernate-core:jar:4.2.5.Final:compile
hibernate核心包
[INFO] org.hibernate.common:hibernate-commons-annotations:jar:4.0.2.Final:compile
hibernate的annotation必备包
[INFO] org.hibernate.javax.persistence:hibernate-jpa-2.0-api:jar:1.0.1.Final:compile
实体类中使用的注解都是在这个JAR包中定义的
[INFO] org.javassist:javassist:jar:3.15.0-GA:compile
代码生成工具, Hibernate用它在运行时扩展 Java类和实现，同cglib
[INFO] org.jboss.logging:jboss-logging:jar:3.1.0.GA:compile
Hibernate的默认包
[INFO] org.jboss.spec.javax.transaction:jboss-transaction-api_1.1_spec:jar:1.0.1.Final:compile
Hibernate的默认包
[INFO] org.springframework:spring-aop:jar:3.2.4.RELEASE:compile
这个jar文件包含在应用中使用Spring的AOP特性时所需的类。使用基于AOP的Spring特性，如声明型事务管理（Declarative Transaction Management ），也要在应用里包含这 个jar包。
[INFO] org.springframework:spring-beans:jar:3.2.4.RELEASE:compile
这个jar文件是所有应用都要用到的，它包含访问配置文件、创建和管理bean以及进行Inversion of Control / Dependency Injection（IoC/DI）操作相关的所有类。
springIoC（依赖注入）的基础实现
如果应用只需基本的IoC/DI支持，引入spring-core.jar及spring-beans.jar文件就可以了。
[INFO] org.springframework:spring-context:jar:3.2.4.RELEASE:compile
spring 提供在基础 IoC 功能上的扩展服务，此外还提供许多企业级服务的支持，如 邮件
服务、任务调度、JNDI定位、EJB 集成、远程访问、 缓存以及各种视图层框架的封装等。
[INFO] org.springframework:spring-core:jar:3.2.4.RELEASE:compile
这个jar文件包含Spring框架基本的核心工具类，Spring其它组件要都要使用到这个包里的类，是其它组件的基本核心，当然你也可以在自己的应用系统中使用这些工具类。
[INFO] org.springframework:spring-expression:jar:3.2.4.RELEASE:compile
spring 表达式语言也就是 spel表达式
[INFO] org.springframework:spring-jdbc:jar:3.2.4.RELEASE:compile
这个jar文件包含对Spring对JDBC数据访问进行封装的所有类。
[INFO] org.springframework:spring-orm:jar:3.2.4.RELEASE:compile
这个jar文件包含Spring对DAO特性集进行了扩展，使其支持 iBATIS、JDO、OJB、TopLink，因为Hibernate已经独立成包了，现在不包含在这个包里了。这个jar文件里大部分的类都 要依赖 spring-dao.jar里的类，用这个包时你需要同时包含spring-dao.jar包。
[INFO] org.springframework:spring-tx:jar:3.2.4.RELEASE:compile
也就是spring对于事务的一些管理


虽然我们这个案例有很多没有用到的jar,但是不管怎么样至少我们不用对用哪个jar而烦心了，但是maven的添加也是由于根据包里所必须的类或方法而添加的虽然我们不用。


再来看一看包之间的依赖关系：
[INFO] +- junit:junit:jar:4.11:compile
[INFO] | \- org.hamcrest:hamcrest-core:jar:1.3:compile
[INFO] +- mysql:mysql-connector-java:jar:5.1.26:compile
[INFO] +- com.alibaba:druid:jar:0.2.25:compile
[INFO] +- org.springframework:spring-context:jar:3.2.4.RELEASE:compile
[INFO] | +- org.springframework:spring-aop:jar:3.2.4.RELEASE:compile
[INFO] | +- org.springframework:spring-beans:jar:3.2.4.RELEASE:compile
[INFO] | +- org.springframework:spring-core:jar:3.2.4.RELEASE:compile
[INFO] | | \- commons-logging:commons-logging:jar:1.1.1:compile
[INFO] | \- org.springframework:spring-expression:jar:3.2.4.RELEASE:compile
[INFO] +- org.springframework:spring-orm:jar:3.2.4.RELEASE:compile
[INFO] | +- aopalliance:aopalliance:jar:1.0:compile
[INFO] | +- org.springframework:spring-jdbc:jar:3.2.4.RELEASE:compile
[INFO] | \- org.springframework:spring-tx:jar:3.2.4.RELEASE:compile
[INFO] +- org.hibernate:hibernate-core:jar:4.2.5.Final:compile
[INFO] | +- antlr:antlr:jar:2.7.7:compile
[INFO] | +- org.jboss.logging:jboss-logging:jar:3.1.0.GA:compile
[INFO] | +- dom4j:dom4j:jar:1.6.1:compile
[INFO] | +- org.jboss.spec.javax.transaction:jboss-transaction-api_1.1_spec:jar:1.0.1.Final:compile
[INFO] | +- org.hibernate.common:hibernate-commons-annotations:jar:4.0.2.Final:compile
[INFO] | \- org.javassist:javassist:jar:3.15.0-GA:compile
[INFO] +- org.aspectj:aspectjweaver:jar:1.7.3:compile
[INFO] \- org.hibernate.javax.persistence:hibernate-jpa-2.0-api:jar:1.0.1.Final:compile

明白了吧！！是不是对jar不是那么畏惧啦！！

2)再来看看maven插件包的含义:

(1).maven-compiler-plugin:
<!-- compiler插件, 设定JDK版本 -->
maven-compiler-plugin用来编译Java代码
(2).maven-war-plugin:
<!-- war插件用于打包成war项目 -->
使用maven-war-plugin这个插件可以在执行打包命令的时候指定我要打哪个环境的包, 而不需要去关注我现在要用什么配置文件了.当然只适用于Maven项目.
虽然不是web项目但是可以把这个项目当脚手架啊！还会扩展成web项目的所以先加上吧！
(3).maven-resources-plugin:
<!-- resource插件, 设定编码 -->
maven-compiler-plugin用来编译Java代码，maven-resources-plugin则用来处理资源文件。默认的主资源文件目录是src/main/resources，很多用户会需要添加额外的资源文件目录，这个时候就可以通过配置maven-resources-plugin来实现。
此外，资源文件过滤也是Maven的一大特性，你可以在资源文件中使用${propertyName}形式的Maven属性，然后配置maven-resources-plugin开启对资源文件的过滤，之后就可以针对不同环境通过命令行或者Profile传入属性的值，以实现更为灵活的构建。
xml、properties文件都是资源文件，编码的时候遇到中文总要进行转码！用什么编码？UTF-8，那就记得强制
(4).maven-jar-plugin
用于打成jar包
(5). maven-source-plugin:
<!-- 源码插件 -->
maven-source-plugin提供项目自动将源码打包并发布的功能
(6). maven-clean-plugin:
清除target 文件夹下由install产生的一些东西例如 war
(7). maven-install-plugin:
用于自动安装项目的主要工件(JAR、WAR或EAR),其POM和任何附加构件(来源、javadoc等)所产生的一个特定的项目。
(8). maven-dependency-plugin:
maven-dependency-plugin最大的用途是帮助分析项目依赖，dependency:list能够列出项目最终解析到的依赖列表，dependency:tree能进一步的描绘项目依赖树，dependency:analyze可以告诉你项目依赖潜在的问题，如果你有直接使用到的却未声明的依赖
，该目标就会发出警告。maven-dependency-plugin还有很多目标帮助你操作依赖文件，例如dependency:copy-dependencies能将项目依赖从本地Maven仓库复制到某个特定的文件夹下面。

数据库

CREATE TABLE `user` (
  `id` int(10) NOT NULL auto_increment,
  `name` varchar(30) default NULL,
  `age` int(3) default NULL,
  PRIMARY KEY  (`id`)
)

applicationContext-dataSource.xml

  <bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource"
        init-method="init" destroy-method="close">
        <property name="url" value="jdbc:mysql://localhost:3306/test2" />
        <property name="username" value="root" />
        <property name="password" value="123" />
        <property name="initialSize" value="1" />
        <property name="maxActive" value="20" />
    </bean>

数据源，druid连接池的简单配置

applicationContext-hibernate.xml


<import resource="applicationContext-dataSource.xml" />

	<bean id="sessionFactory"
		class="org.springframework.orm.hibernate4.LocalSessionFactoryBean">
		<property name="dataSource" ref="dataSource" />
		<property name="packagesToScan" value="com.entity" /><!--自动扫描指定的包下面注解的实体类，也就是User类 -->
		<property name="hibernateProperties">
			<props>
				<prop key="hibernate.dialect">org.hibernate.dialect.MySQLDialect</prop>
				<prop key="hibernate.show_sql">true</prop>
				<prop key="hibernate.format_sql">false</prop>
				<prop key="hibernate.use_sql_comments">false</prop>
				<prop key="hibernate.cache.use_second_level_cache">false</prop>
			</props>
		</property>
	</bean>
	<!-- start spring集中式声明 -->
	<tx:advice id="txAdvice" transaction-manager="transactionManager">
		<tx:attributes>
			<tx:method name="saveUser*" />
			<tx:method name="saveUserThrowException*" rollback-for="Exception"/>
			<tx:method name="findUsers*" read-only="true"/>
			 <!--hibernate4必须配置为开启事务 否则 getCurrentSession()获取不到session-->  
			<tx:method name="*"  propagation="REQUIRED" />
		</tx:attributes>
	</tx:advice>
	
	<aop:config>
		<aop:pointcut id="productServiceMethods" expression="execution(* com.service..*.*(..))"/>
		<aop:advisor advice-ref="txAdvice" pointcut-ref="productServiceMethods" />
	</aop:config>
	<!-- spring集中式声明 -->
	
	<bean id="userService" class="com.service.impl.UserService">
		<property name="userDao">
			<bean class="com.dao.impl.UserDaoImpl">
				<property name="sessionFactory" ref="sessionFactory"></property>
			</bean>
		</property>
	</bean>
	<!-- 事务管理器 -->
	<bean id="transactionManager"
		class="org.springframework.orm.hibernate4.HibernateTransactionManager">
		<property name="sessionFactory" ref="sessionFactory" />
	</bean>

下面我们来看看这个配置文件各个参数的作用吧!
1).<import resource="applicationContext-dataSource.xml" />导入数据源
2).<bean id="sessionFactory"
class="org.springframework.orm.hibernate4.LocalSessionFactoryBean">
<property name="dataSource" ref="dataSource" /><!--把dataSource链接进来-->
<property name="packagesToScan" value="com.entity" /><!--自动扫描指定的包下面注解的实体类，也就是User类 -->
<property name="hibernateProperties"><!--配置hibernate的属性-->
<props>
<prop key="hibernate.dialect">org.hibernate.dialect.MySQLDialect</prop><!--定义mysql方言-->
<prop key="hibernate.show_sql">true</prop><!--输出所有SQL语句到控制台-->
<prop key="hibernate.format_sql">false</prop><!--在log和console中打印出更漂亮的SQL-->
<prop key="hibernate.use_sql_comments">false</prop><!--如果开启, Hibernate将在SQL中生成有助于调试的注释信息-->
<prop key="hibernate.cache.use_second_level_cache">false</prop><!--能用来完全禁止使用二级缓存. 对那些在类的映射定义中指定<cache>的类，会默认开启二级缓存-->
</props>
</property>
</bean>
3).<!-- start spring集中式声明 -->
<tx:advice id="txAdvice" transaction-manager="transactionManager">
<tx:attributes>
<tx:method name="saveUser*" />
<tx:method name="saveUserThrowException*" rollback-for="Exception"/>
<tx:method name="findUsers*" read-only="true"/>
<!--hibernate4必须配置为开启事务 否则 getCurrentSession()获取不到session-->
<tx:method name="*" propagation="REQUIRED" />
</tx:attributes>
</tx:advice>
<aop:config>
<aop:pointcut id="productServiceMethods" expression="execution(* com.service..*.*(..))"/>
<aop:advisor advice-ref="txAdvice" pointcut-ref="productServiceMethods" />
</aop:config>
<!-- spring集中式声明 -->
集中式声明也就是采用AOP的方式,进行拦截式声明
我们再来了解下expression的表达式作用：
* com.service..*.*(..)
第一个*代表所有的返回值类型
第二个*代表所有的类
第三个*代表类所有方法
最后一个(..)代表所有的参数。
service.. 意思是：service包或者子包
service.意思是：service包
再来了解下网上给的常见的例子：我再详细解释下
  • 任意公共方法的执行：大概意思是符合 public *(所有返回值) *(所有方法名) (..)(所有的参数)
  • execution(public * *(..))
  • 任何一个以“set”开始的方法的执行：*(所有返回值) set*(所有名)(..)(所有的参数)
  • execution(* set*(..))
  • AccountService 接口的任意方法的执行：*(所有返回值).*(所有方法名)(..)(所有的参数)
  • execution(* com.xyz.service.AccountService.*(..))
  • 定义在service包里的任意方法的执行：*(所有返回值).*(service包下的所有类).*(所有方法名)(..)(所有的参数)
  • execution(* com.xyz.service.*.*(..))
  • 定义在service包或者子包里的任意类的任意方法的执行：*(所有返回值) ..*(service包或子包下的所有类) .*(所有方法名)(..)(所有的参数)
  • execution(* com.xyz.service..*.*(..))

4).<bean id="userService" class="com.service.impl.UserService">
<property name="userDao">
<bean class="com.dao.impl.UserDaoImpl">
<property name="sessionFactory" ref="sessionFactory"></property>
</bean>
</property>
</bean>
把dao注入到service中而没有采用,注解的方式自动装载
5). <!-- 事务管理器 -->
<bean id="transactionManager"
class="org.springframework.orm.hibernate4.HibernateTransactionManager">
<property name="sessionFactory" ref="sessionFactory" />
</bean>
这个不用多说了吧！一个事务的管理器

至此集中式声明就配置完毕啦！！
下面再来看看dao service test吧！

IUserDao.java

public interface IUserDao {
    public void save(User user);
    public List<User> query(String sql,Object[] args);
}

UserDaoImpl.java

public class UserDaoImpl extends AbstractHibernateDao<User> implements IUserDao {

    public UserDaoImpl() {
        super(User.class);
    }
}
这块其实写的就是为了更灵活一些,把想要查询的实体一改就可以换成另一种实体的查询,而不用改具体实现的代码,对于这种常用的方法调用,可以防止方法的冗余,真的很不错啊！

AbstractHibernateDao.java

public abstract class AbstractHibernateDao <E extends Serializable>{
    private Class<E> entityClass;
    private SessionFactory sessionFactory;
     
    protected AbstractHibernateDao(Class<E> entityClass) {
        this.entityClass = entityClass;
    }
 
    public Session getCurrentSession() {
        return sessionFactory.getCurrentSession();
    }
 
    public E findById(Serializable id) {
        return (E) getCurrentSession().get(entityClass, id);
    }
 
    public void save(E e) {
        getCurrentSession().save(e);
    }
 
    public void delete(E e) {
        getCurrentSession().delete(e);
    }
 
    public List<E> query(String hql, Object[] args) {
        Query query=getCurrentSession().createQuery(hql);
        if(args!=null){
            for (int i = 0; i < args.length; i++) {
                query.setParameter(i, args[i]);
            }
        }
        return query.list();
    }

	public Class<E> getEntityClass() {
		return entityClass;
	}

	public void setEntityClass(Class<E> entityClass) {
		this.entityClass = entityClass;
	}

	public SessionFactory getSessionFactory() {
		return sessionFactory;
	}

	public void setSessionFactory(SessionFactory sessionFactory) {
		this.sessionFactory = sessionFactory;
	}

   
}

User.java

@Entity
@Table(name="user")
public class User implements Serializable{
    private static final long serialVersionUID = 1724315528421427938L;
    
    @Id
    @GeneratedValue(strategy=GenerationType.IDENTITY)
    @Column(name = "id", nullable = false)   
    private Long id;
    @Column(name="name",nullable=true,length=25)
    private String name;
    @Column(name="age",nullable=true)
    private Integer age;
   ........
    set...
    get...
   ........
	@Override
    public String toString() {
        return "User [id=" + id + ", name=" + name + ", age=" + age + "]";
    }
}

IUserService.java

public interface IUserService {
    void saveUser();
    void saveUserThrowException() throws Exception;
    void findUsers();
}

UserService.java

public class UserService implements IUserService{
    private IUserDao userDao;
	public IUserDao getUserDao() {
		return userDao;
	}
	public void setUserDao(IUserDao userDao) {
		this.userDao = userDao;
	}
	public void saveUser() {
        User u1=new User();
        u1.setName("邵");
        u1.setAge(24);
        userDao.save(u1);

        User u2=new User();
        u2.setName("陈");
        u2.setAge(20);
        userDao.save(u2);
    }
    public void saveUserThrowException() throws Exception {
        User u1=new User();
        u1.setName("邵");
        u1.setAge(24);
        userDao.save(u1);   
        if(1+1>1){
            throw new Exception("Runtime error...");//抛出一般的异常：Exception
        }    
        User u2=new User();
        u2.setName("陈");
        u2.setAge(20);
        userDao.save(u2);      
    }
    public void findUsers() {
        List<User> users=userDao.query("from User where name=?", new Object[]{"邵"});
        for (User user : users) {
            System.out.println(user);
        }
    } 
}

SpringHibernateTest.java

public class SpringHibernateTest {
    private static ApplicationContext ctx = null;

    @BeforeClass 
    public static void onlyOnce() {
         ctx = new ClassPathXmlApplicationContext("applicationContext-hibernate.xml");
    }
    @Test
    public void testSave(){
        IUserService service=ctx.getBean("userService",IUserService.class);
        service.saveUser();
    }
    
//    @Test
    public void testSaveThrowException() throws Exception{
        IUserService service=ctx.getBean("userService",IUserService.class);
        service.saveUserThrowException();
    } 
    @Test
    public void testJDBCDaoQuery(){
        IUserService service=ctx.getBean("userService",IUserService.class);
        service.findUsers();
    }
}

注解式事务管理:

applicationContext-dataSource.xml

与上面声明式事务一样的配置

applicationContext-hibernate.xml

 <import resource="applicationContext-dataSource.xml" />

    <bean id="sessionFactory" class="org.springframework.orm.hibernate4.LocalSessionFactoryBean">
        <property name="dataSource" ref="dataSource" />
        <property name="packagesToScan" value="com.entity" />
        <property name="hibernateProperties">
            <props>
                <prop key="hibernate.dialect">org.hibernate.dialect.MySQLDialect</prop>
                <prop key="hibernate.show_sql">true</prop>
                <prop key="hibernate.format_sql">false</prop>
                <prop key="hibernate.use_sql_comments">false</prop>
                <prop key="hibernate.cache.use_second_level_cache">false</prop>
            </props>
        </property>
    </bean>
    
    <bean id="userService" class="com.service.impl.UserService">
        <property name="userDao">
            <bean class="com.dao.impl.UserDaoImpl">
                <property name="sessionFactory" ref="sessionFactory"></property>
            </bean>
        </property>
    </bean>
 
    <!-- 事务管理器 -->  
    <bean id="transactionManager" class="org.springframework.orm.hibernate4.HibernateTransactionManager">  
        <property name="sessionFactory" ref="sessionFactory"/>  
    </bean> 
    
    <tx:annotation-driven transaction-manager="transactionManager"/><!--启动注解用注解来管理事务-->

<tx:annotation-driven transaction-manager="transactionManager"/>它是注解配置事务的关键

AbstractHibernateDao、UserDaoImpl、IUserDao、User、IUserService的配置与声明式事务一样的配置

不一样的地方：

UserService.java

@Transactional//默认propagation=Propagation.REQUIRED所以不像集中式声明那样都要配置
public class UserService implements IUserService{
    private IUserDao userDao;

    public void saveUser() {
        User u1=new User();
        u1.setName("邵");
        u1.setAge(24);
        userDao.save(u1);
        
        //测试时，可以添加此异常，或去掉异常，测试Spring对事物的管理
//        if(1+1>1){
//            throw new RuntimeException("Runtime error...");//抛出运行时异常：RuntimeException
//        }
        
        User u2=new User();
        u2.setName("陈");
        u2.setAge(20);
        userDao.save(u2);
    }

    @Transactional(rollbackFor={Exception.class})
    public void saveUserThrowException() throws Exception {
        User u1=new User();
        u1.setName("邵");
        u1.setAge(24);
        userDao.save(u1);
        
        if(1+1>1){
            throw new Exception("Runtime error...");//抛出一般的异常：Exception
        }
        
        User u2=new User();
        u2.setName("陈");
        u2.setAge(20);
        userDao.save(u2);
        
    }
    
    @Transactional(readOnly=true) 
    public void findUsers() {
        List<User> users=userDao.query("from User where name=?", new Object[]{"邵"});
        for (User user : users) {
            System.out.println(user);
        }
    }
    
    public IUserDao getUserDao() {
        return userDao;
    }
    public void setUserDao(IUserDao userDao) {
        this.userDao = userDao;
    }
}

@Transactional//默认propagation=Propagation.REQUIRED所以不像集中式声明那样都要配置
@Transactional(readOnly=true)readOnly=true表明所注解的方法或类只是读取数据。
 readOnly=false表明所注解的方法或类是增加，删除，修改数据。



注解与XML配置的区别

注解：是一种分散式的元数据，与源代码紧绑定。

xml：是一种集中式的元数据，与源代码无绑定。


更多关于spring注解与xml的区别请参照我的这篇博客http://blog.csdn.net/lzwglory/article/details/16340435


至此注解的事务配置也完成啦！关于spring系列、hibernate系列后续还会更新请多关注我的博客！！













分享到：
| Spirng3基于注解(annotation)整合ehcache ...
评论
发表评论

您还没有登录,请您登录后再发表评论

相关推荐

    spring3hibernate4集中式声明

    4. **事务管理**：Spring3提供了一种声明式事务管理，允许在配置文件中定义事务规则，如传播行为、隔离级别等。这样，事务的边界可以在不修改业务代码的情况下灵活控制。 5. **数据源配置**：Spring可以管理数据库...

    spring mvc + spring + hibernate 全注解整合开发视频教程 09

    - **事务管理**：Spring如何结合Hibernate提供声明式事务管理，通过@Transactional注解实现事务的开始、提交和回滚。 - **整合测试**：如何使用JUnit和Mockito等工具进行集成测试，验证三大框架的协同工作。 此外，...

    Spring整合HIbernate

    2. **事务管理**：Spring提供了声明式事务管理，可以无缝集成到Hibernate的Session中，使得事务处理更加简单、统一。 3. **DAO（Data Access Object）抽象**：Spring的HibernateTemplate和HibernateDaoSupport为...

    struts hibernate spring 全注解开发框架

    此外，`@Autowired`注解可以自动装配Bean的依赖，而`@Transactional`注解则用于声明式事务管理。 Hibernate是Java持久层的一个优秀解决方案，它简化了数据库操作。在Hibernate3.3中，我们可以通过注解直接在实体类...

    spring3mvc+hibernate4+spring-security3+dwr3整合架包

    本篇文章将深入探讨“spring3mvc+hibernate4+spring-security3+dwr3整合架包”中的核心技术和概念，帮助开发者理解如何利用这些组件来创建强大的Java Web应用。 首先，Spring MVC（Model-View-Controller）是Spring...

    spring+hibernate代码实例集

    2.1 Spring提供了声明式事务管理，通过@Transactional注解，可以在方法级别控制事务的开始、提交、回滚。这种方式使得事务管理更加简单，开发者无需关注具体的事务操作，只需在业务逻辑中添加注解即可。 2.2 ...

    Spring+Hibernate+SpringMVC+Maven整合

    通过Spring的声明式事务管理，可以简化事务控制，减少代码中的错误。而Maven则保证了项目的构建一致性，方便进行版本管理和构建自动化。 总结来说，"Spring+Hibernate+SpringMVC+Maven整合"是现代Java Web开发中的...

    用 Hibernate 和 Spring 开发持久层

    - **事务处理**：Hibernate可以与Spring框架结合，利用Spring的声明式事务管理，为数据访问操作提供一致性的事务边界。 #### Spring框架的作用 Spring框架是一个轻量级的控制反转（IoC）和面向切面编程（AOP）容器...

    tapestry4+spring+hibernate整合实例

    Tapestry4 是一个MVC（Model-View-Controller）框架，提供了一种声明式编程模型，使得开发者可以更专注于业务逻辑，而不是页面的组装。Spring 是一个全面的后端框架，它提供了依赖注入、事务管理、AOP（面向切面编程...

    spring_hibernate

    - **事务管理**：Spring 提供了优秀的事务管理机制，可以使用编程式或声明式事务管理，配合 Hibernate 实现事务控制。 - **DAO（Data Access Object）层**：Spring 提供了模板类，如 `HibernateTemplate` 或 `...

    pro spring 4

    - **事务管理**：Spring提供了强大的事务管理能力，支持编程式事务管理和声明式事务管理，便于开发者控制事务边界。 ### Web应用开发 - **Spring MVC**：Spring的Model-View-Controller (MVC) 模块是构建Web应用的...

    Spring 事务配置详解(多种配置方法)

    在Spring框架中，事务管理是核心功能之一，它允许开发者以声明式或编程式的方式控制事务的边界。本文将详细解析Spring事务配置的多种方法，包括XML配置和注解方式。 首先，理解Spring事务配置的基本组件至关重要。...

    最全的Spring考题与答案

    - **声明式事务管理**：通过注解或XML配置，简化事务管理，减少代码冗余。 - 使用`@Transactional`注解进行方法级别的事务配置，如`PROPAGATION_REQUIRED`表示支持当前事务，无事务则新建。 通过上述讲解，我们...

    struts spring hibernate 优缺点分析.docx

    8. **事务管理**：通过AOP实现声明式事务管理，简化事务控制。 9. **邮件支持**：支持JavaMail或其他邮件系统，增强应用功能。 尽管Spring非常强大，但也有一些缺点： 1. **学习成本**：Spring框架庞大，学习和...

    spring面试题大全

    2. 声明式事务管理：通过注解或XML配置，Spring会自动管理事务的开始、提交、回滚。如使用@Transactional注解标记方法，指定传播行为（如PROPAGATION_REQUIRED表示必须在事务中运行，无事务则新建）。 声明式事务...

    Struts 2,Spring 2,Hibernate S2SH 整合 例子 源代码

    Spring能够将Action实例注入到Struts 2 中，这样在Action中可以直接使用Spring管理的Service层对象来完成业务逻辑，Service层再通过Hibernate与数据库进行交互。这种整合方式使得各组件职责明确，提高了代码的可维护...

    jsp源码内容管理系统(hibernate3+struts2+spring2)130224

    根据提供的文件信息，我们可以深入探讨该系统的架构与关键技术——JSP源码内容管理系统（采用Hibernate3、Struts2和Spring2技术栈），并结合实际应用背景进行详细解析。 ### 一、项目概述 #### 1.1 核心技术栈 - ...

    学习spring的好东西

    Spring提供了对JDBC、Hibernate等数据访问技术的集成，支持声明式事务管理，简化了数据访问层的编写，如使用Hibernate的Session、Query等对象。 **九、Struts2与Spring的整合** Spring可以通过struts-spring-plugin...

    spring-analysis-master.zip

    2. 声明式事务管理：基于AOP，通过@Transactional注解实现事务的自动管理，简化了事务处理代码。 五、Spring Boot 1. Spring Boot简化了Spring应用的初始搭建和配置，通过自动配置和起步依赖，快速启动微服务。 2...

    08JDBC的事务处理.zip

    1. **声明式事务管理**：通过在XML配置文件或使用注解（如`@Transactional`）来声明事务边界。Spring会自动处理事务的开始、提交和回滚，使得代码更简洁、可维护。 2. **编程式事务管理**：使用`...

Magicbox
Global site tag (gtag.js) - Google Analytics