spring 两种事务的使用

最新推荐文章于 2020-03-09 15:09:17 发布
最新推荐文章于 2020-03-09 15:09:17 发布
阅读量3.7k 收藏
点赞数
分类专栏： 开发随笔 java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/moliqin/article/details/10290001
版权

1. 在代码中使用 @Transactional

具体实现

applicationContext-dao.xml

 <?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:tx="http://www.springframework.org/schema/tx"
    xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-3.1.xsd
         http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-3.1.xsd"
          default-lazy-init="true">
        
   <bean class="org.springframework.dao.annotation.PersistenceExceptionTranslationPostProcessor"/>

    <!-- EntityManagerFactory -->
    <bean id="entityManagerFactory1" class="org.springframework.orm.jpa.LocalContainerEntityManagerFactoryBean">
        <property name="persistenceUnitManager" ref="persistenceUnitManager"/>
        <property name="jpaProperties">
            <props>
                <prop key="hibernate.dialect">${hibernate.dialect}</prop>
                <prop key="hibernate.query.substitutions">true 'Y', false 'N'</prop>
                <prop key="hibernate.cache.use_second_level_cache">true</prop>
                <prop key="hibernate.cache.provider_class">org.hibernate.cache.EhCacheProvider</prop>
 
            </props>
    
        </property>
    </bean>

    <bean id="persistenceUnitManager" class="org.springframework.orm.jpa.persistenceunit.DefaultPersistenceUnitManager">
        <property name="persistenceXmlLocations">
            <list>
                <value>classpath:META-INF/persistence.xml</value>
            </list>
        </property>
        <property name="defaultDataSource" ref="dataSource"/>
    </bean>

    <!-- Needed so the @PersistenceUnit annotation is recognized -->
    <bean class="org.springframework.orm.jpa.support.PersistenceAnnotationBeanPostProcessor"/>

     
     <bean id="myTxManager"    class="org.springframework.orm.jpa.JpaTransactionManager">
         <property name="entityManagerFactory" ref="entityManagerFactory1" />
  </bean>
   <tx:annotation-driven transaction-manager="myTxManager" />
 

    <!-- Activates scanning of @Repository -->
    <context:component-scan base-package="com.pcjavanet.dao"/>
    
</beans>



applicationContext-resource.xml

<?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"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.1.xsd
            http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-3.1.xsd">

    <context:property-placeholder location="classpath:hibernate.properties,classpath:jdbc.properties"/>

    <bean id="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}"/>
        <property name="maxActive" value="100"/>
        <property name="maxWait" value="1000"/>
        <property name="poolPreparedStatements" value="true"/>
        <property name="defaultAutoCommit" value="true"/>
    </bean>
</beans>

jdbc.properties

# If you want Maven to populate this file from its properties, uncomment the following section, remove the other
# sections and remove the <filters> element from pom.xml.
# -----------------------------------------
#jdbc.driverClassName=${jdbc.driverClassName}
#jdbc.url=${jdbc.url}
#jdbc.username=${jdbc.username}
#jdbc.password=${jdbc.password}

#hibernate.dialect=${hibernate.dialect}

# Needed by Hibernate3 Maven Plugin defined in pom.xml
#hibernate.connection.username=${jdbc.username}
#hibernate.connection.password=${jdbc.password}
#hibernate.connection.url=${jdbc.url}
#hibernate.connection.driver_class=${jdbc.driverClassName}

# MySQL
# -----------------------------------------
#jdbc.driverClassName=com.mysql.jdbc.Driver
#jdbc.url=jdbc:mysql://localhost/appfuse?createDatabaseIfNotExist=true&amp;useUnicode=true&amp;characterEncoding=utf-8
#jdbc.username=root
#jdbc.password=

#hibernate.dialect=org.hibernate.dialect.MySQL5InnoDBDialect

# Needed by Hibernate3 Maven Plugin defined in pom.xml
#hibernate.connection.username=root
#hibernate.connection.password=
#hibernate.connection.url=jdbc:mysql://localhost/appfuse?createDatabaseIfNotExist=true&amp;useUnicode=true&amp;characterEncoding=utf-8
#hibernate.connection.driver_class=com.mysql.jdbc.Driver

# H2
# -----------------------------------------
#jdbc.driverClassName=org.h2.Driver
#jdbc.url=jdbc:h2:/tmp/appfuse_light
#jdbc.username=sa
#jdbc.password=

#hibernate.dialect=org.hibernate.dialect.H2Dialect
hibernate.dialect=org.hibernate.dialect.PostgreSQLDialect
jdbc.driverClassName=org.postgresql.Driver
jdbc.url=jdbc:postgresql://127.0.0.1:5432/jpa
jdbc.username=postgres
jdbc.password=dbms4Fna
# Needed by Hibernate3 Maven Plugin defined in pom.xml
hibernate.connection.username=postgres
hibernate.connection.password=postgres
hibernate.connection.url=jdbc:postgresql://127.0.0.1:5432/jpa
hibernate.connection.driver_class=org.postgresql.Driver

hibernate.properties

app.search.index.basedir=${search.index.basedir}
hibernate.search.default.directory_provider=filesystem
hibernate.search.default.locking_strategy=simple
hibernate.search.default.exclusive_index_use=true
hibernate.search.lucene_version=LUCENE_35
hibernate.search.analyzer=org.apache.lucene.analysis.en.EnglishAnalyzer
hibernate.search.worker.batch_size=100


UserDaoJpa.java

package com.pcjavanet.dao;

import org.springframework.stereotype.Repository;
import org.springframework.transaction.annotation.Transactional;

import com.pcjavanet.model.User;

@Repository("userDao")
//@Service("userDao")
public class UserDaoJpa extends GenericDaoJpa<User, Long>  implements UserDao{


/* 还可以继续使用jdbcTemplate*/
 @Autowired
    private DataSource dataSource;    

    public void  xxxx ( ) {
        JdbcTemplate jdbcTemplate = new JdbcTemplate(dataSource);
        Table table = AnnotationUtils.findAnnotation(User.class, Table.class);
        String sql ="xxxx";

jdbcTemplate.query(sql,
                new PreparedStatementSetter() {
                    public void setValues(PreparedStatement ps)    throws SQLException {                            
                    }
                },
                new RowCallbackHandler() {
                    public void processRow(ResultSet rs) throws SQLException {
                    }
        });
    }



    @Transactional
    public User saveUser( User user ) {
        User u = super.save(user);
        System.out.println( u );
        getEntityManager().flush();
        return u;
    }
}

UserDao.java

package com.pcjavanet.dao;

import com.pcjavanet.model.User;

 
public interface UserDao extends GenericDao<User, Long> {
 
    User saveUser(User user);
 
}

GenericDao.java


package com.pcjavanet.dao;

import java.io.Serializable;


 
public interface GenericDao <T, PK extends Serializable> {
    T save(T object);
}

GenericDaoJpa.java

package com.pcjavanet.dao;

import java.io.Serializable;

import javax.persistence.EntityManager;
import javax.persistence.PersistenceContext;

import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;

public class GenericDaoJpa<T, PK extends Serializable> implements GenericDao<T, PK> {
    /**
     * Log variable for all child classes. Uses LogFactory.getLog(getClass()) from Commons Logging
     */
    protected final Log log = LogFactory.getLog(getClass());

    public static final String PERSISTENCE_UNIT_NAME = "ApplicationEntityManager";
    @PersistenceContext(unitName=PERSISTENCE_UNIT_NAME)
    private EntityManager entityManager;
    
     public T save(T object) {
        return this.entityManager.merge(object);
    }
    
    public EntityManager getEntityManager() {
        return this.entityManager;
    }
}

测试代码

TestMain.java


package com.pcjavanet.execute;

import org.springframework.context.support.ClassPathXmlApplicationContext;

import com.pcjavanet.dao.UserDao;
import com.pcjavanet.model.User;
 
public class TestMain {
 
 
    public static void main(String[] args) {
        
        
           String[] locations = {
 
                   "applicationContext-resource.xml", "applicationContext-dao.xml"};
           org.springframework.context.support.ClassPathXmlApplicationContext ctx = (org.springframework.context.support.ClassPathXmlApplicationContext)new ClassPathXmlApplicationContext(locations);
         
           User u = new User();
           u.setUserName("Jack MO");
           UserDao userDao = (UserDao)   ctx.getBean("userDao");
           userDao.saveUser( u );
 
    }

}

User.java

package com.pcjavanet.model;

import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.SequenceGenerator;
import javax.persistence.Table;

import org.hibernate.search.annotations.DocumentId;
import org.hibernate.search.annotations.Field;

@Entity
@Table(name = "app_user")
public class User {
    @Override
    public String toString() {
        return "User [userId=" + userId + ", userName=" + userName + "]";
    }
    private int userId ;
    private String userName ;
    private int age ;
    private int sex ;
 
    @Id
    @GeneratedValue(strategy = GenerationType.SEQUENCE, generator = "profile_seq")
    @SequenceGenerator(name = "profile_seq", sequenceName = "profile_seq",allocationSize=1 ) //产生Seq,设定步长
    @DocumentId
    public int getUserId() {
        return userId;
    }
    public void setUserId(int userId) {
        this.userId = userId;
    }
    @Column(nullable = false, length = 50)
    @Field
    public String getUserName() {
        return userName;
    }
    public void setUserName(String userName) {
        this.userName = userName;
    }
 
     @Column(nullable = false )
     @Field
    public int getSex() {
        return sex;
    }
    public void setSex(int sex) {
        this.sex = sex;
    }
}

2. 在配置文件配置AOP

需要更改的代码有TestMain.java 和UserDaoJpa.java

另外需要新增service层

UserManagerImpl.java

package com.pcjavanet.service;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import com.pcjavanet.dao.UserDao;
import com.pcjavanet.model.User;
@Service("userManager")
public class UserManagerImpl /* extends GenericManagerImpl<User, Long>   {
 
    @Autowired
    private UserDao userDao;
    public User saveUser(User user) throws UserExistsException {
            return userDao.saveUser(user);
 
    }
}


UserManager.java

package com.pcjavanet.service;

import com.pcjavanet.model.User;

 
public interface UserManager  {
 
    User saveUser(User user) throws UserExistsException;
 
}

UserExistsException.java

package com.pcjavanet.service;

 
public class UserExistsException extends Exception {
    private static final long serialVersionUID = 4050482305178810162L;

    /**
     * Constructor for UserExistsException.
     *
     * @param message exception message
     */
    public UserExistsException(final String message) {
        super(message);
    }
}

新的 TestMain.java

package com.pcjavanet.execute;

import org.springframework.context.support.ClassPathXmlApplicationContext;

import com.pcjavanet.model.User;
import com.pcjavanet.service.UserExistsException;
import com.pcjavanet.service.UserManager;
 
public class TestMain {
 
 
    public static void main(String[] args) {
        
        
           String[] locations = {
                   "applicationContext-service.xml",
                   "applicationContext-resource.xml", "applicationContext-dao.xml"};
           org.springframework.context.support.ClassPathXmlApplicationContext ctx = (org.springframework.context.support.ClassPathXmlApplicationContext)new ClassPathXmlApplicationContext(locations);
 
           User u = new User();
 
           u.setUserName("Jack MO");
 
           UserManager userM = (UserManager) ctx.getBean("userManager");
           try {
            userM.saveUser(u);
        } catch (UserExistsException e) {
            
            e.printStackTrace();
        }
    }

}

新 UserDaoJpa.java

package com.pcjavanet.dao;

import org.springframework.stereotype.Repository;

import com.pcjavanet.model.User;

@Repository("userDao")
//@Service("userDao")
public class UserDaoJpa extends GenericDaoJpa<User, Long>  
//{
implements UserDao{
 
    public User saveUser( User user ) {
        User u = super.save(user);
        System.out.println( u );
        getEntityManager().flush();
        return u;
    }
}

Pom.xml


<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd">

    <modelVersion>4.0.0</modelVersion>
    <groupId>com.pcjavanet</groupId>
    <artifactId>jpsstudy</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <build>
        <defaultGoal>install</defaultGoal>
        <plugins>

            <plugin>
                <artifactId>maven-compiler-plugin</artifactId>
                <version>2.5.1</version>
                <configuration>
                    <source>1.6</source>
                    <target>1.6</target>
                </configuration>
            </plugin>

        </plugins>
    </build>
    <dependencies>
        <dependency>
            <groupId>org.hibernate</groupId>
            <artifactId>hibernate-search</artifactId>
            <version>${hibernate.search.version}</version>
            <exclusions>
                <exclusion>
                    <artifactId>hibernate-core</artifactId>
                    <groupId>org.hibernate</groupId>
                </exclusion>
            </exclusions>
        </dependency>
        <dependency>
            <groupId>org.hibernate</groupId>
            <artifactId>hibernate-core</artifactId>
            <version>${hibernate.version}</version>
        </dependency>
        <dependency>
            <groupId>org.hibernate</groupId>
            <artifactId>hibernate-search-analyzers</artifactId>
            <version>${hibernate.search.version}</version>
        </dependency>
        <dependency>
            <groupId>org.hibernate</groupId>
            <artifactId>hibernate-entitymanager</artifactId>
            <version>${hibernate.entitymanager.version}</version>
        </dependency>
        <dependency>
            <groupId>org.hibernate</groupId>
            <artifactId>hibernate-ehcache</artifactId>
            <version>${hibernate.version}</version>
        </dependency>
        <dependency>
            <groupId>org.hibernate.java-persistence</groupId>
            <artifactId>jpa-api</artifactId>
            <version>${jpa.version}</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-test</artifactId>
            <version>${spring.version}</version>
            <optional>true</optional>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-aop</artifactId>
            <version>${spring.version}</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-jdbc</artifactId>
            <version>${spring.version}</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-orm</artifactId>
            <version>${spring.version}</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-aspects</artifactId>
            <version>${spring.version}</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context-support</artifactId>
            <version>${spring.version}</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-webmvc</artifactId>
            <version>${spring.version}</version>
        </dependency>
        <dependency>
            <groupId>org.springframework.security</groupId>
            <artifactId>spring-security-core</artifactId>
            <version>${spring.security.version}</version>
            <exclusions>
                <exclusion>
                    <artifactId>spring-aop</artifactId>
                    <groupId>org.springframework</groupId>
                </exclusion>
                <exclusion>
                    <artifactId>spring-beans</artifactId>
                    <groupId>org.springframework</groupId>
                </exclusion>
                <exclusion>
                    <artifactId>spring-context</artifactId>
                    <groupId>org.springframework</groupId>
                </exclusion>
                <exclusion>
                    <artifactId>spring-core</artifactId>
                    <groupId>org.springframework</groupId>
                </exclusion>
                <exclusion>
                    <artifactId>spring-expression</artifactId>
                    <groupId>org.springframework</groupId>
                </exclusion>
            </exclusions>
        </dependency>
        <dependency>
            <groupId>org.springframework.security</groupId>
            <artifactId>spring-security-config</artifactId>
            <version>${spring.security.version}</version>
            <exclusions>
                <exclusion>
                    <artifactId>spring-aop</artifactId>
                    <groupId>org.springframework</groupId>
                </exclusion>
                <exclusion>
                    <artifactId>spring-beans</artifactId>
                    <groupId>org.springframework</groupId>
                </exclusion>
                <exclusion>
                    <artifactId>spring-context</artifactId>
                    <groupId>org.springframework</groupId>
                </exclusion>
                <exclusion>
                    <artifactId>spring-core</artifactId>
                    <groupId>org.springframework</groupId>
                </exclusion>
            </exclusions>
        </dependency>
        <dependency>
            <groupId>org.springframework.security</groupId>
            <artifactId>spring-security-taglibs</artifactId>
            <version>${spring.security.version}</version>
            <exclusions>
                <exclusion>
                    <artifactId>spring-expression</artifactId>
                    <groupId>org.springframework</groupId>
                </exclusion>
                <exclusion>
                    <artifactId>spring-context</artifactId>
                    <groupId>org.springframework</groupId>
                </exclusion>
                <exclusion>
                    <artifactId>spring-web</artifactId>
                    <groupId>org.springframework</groupId>
                </exclusion>
            </exclusions>
        </dependency>
        <dependency>
            <groupId>commons-beanutils</groupId>
            <artifactId>commons-beanutils</artifactId>
            <version>${commons.beanutils.version}</version>
        </dependency>
        <dependency>
            <groupId>commons-collections</groupId>
            <artifactId>commons-collections</artifactId>
            <version>${commons.collections.version}</version>
        </dependency>
        <dependency>
            <groupId>commons-dbcp</groupId>
            <artifactId>commons-dbcp</artifactId>
            <version>${commons.dbcp.version}</version>
            <exclusions>
                <exclusion>
                    <artifactId>xercesImpl</artifactId>
                    <groupId>xerces</groupId>
                </exclusion>
                <exclusion>
                    <artifactId>commons-collections</artifactId>
                    <groupId>commons-collections</groupId>
                </exclusion>
            </exclusions>
        </dependency>
        <dependency>
            <groupId>commons-lang</groupId>
            <artifactId>commons-lang</artifactId>
            <version>${commons.lang.version}</version>
        </dependency>
        <dependency>
            <groupId>postgresql</groupId>
            <artifactId>postgresql</artifactId>
            <version>8.3-603.jdbc4</version>
        </dependency>
        <dependency>
            <groupId>org.aspectj</groupId>
            <artifactId>aspectjweaver</artifactId>
            <version>${aspectj.version}</version>
        </dependency>
    </dependencies>
    <properties>
       <aspectj.version>1.6.10</aspectj.version>
        <commons.beanutils.version>1.8.3</commons.beanutils.version>
        <commons.collections.version>3.2.1</commons.collections.version>
        <commons.dbcp.version>1.3</commons.dbcp.version>
        <commons.lang.version>2.6</commons.lang.version>
        <jmock.version>2.5.1</jmock.version>
        <junit.version>4.10</junit.version>
        <jwebunit.version>2.5</jwebunit.version>
        <spring.version>3.1.3.RELEASE</spring.version>
        <spring.security.version>3.1.3.RELEASE</spring.security.version>
        <!-- Application settings -->
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <copyright.year>2012</copyright.year>
        <dao.framework>jpa</dao.framework>
        <web.framework>struts</web.framework>
        <amp.genericCore>true</amp.genericCore>
        <amp.fullSource>false</amp.fullSource>
        <db.name>jpa</db.name>
        <ehcache.web.version>2.0.4</ehcache.web.version>
        <hibernate.entitymanager.version>4.1.8.Final</hibernate.entitymanager.version>
        <jpa.version>2.0-cr-1</jpa.version>
        <hibernate.search.version>4.1.1.Final</hibernate.search.version>
        <hibernate.version>4.1.8.Final</hibernate.version>
        <cargo.version>1.2.4</cargo.version>
        <jmock.version>2.5.1</jmock.version>
        <jsp.version>2.1</jsp.version>
        <junit.version>4.10</junit.version>
        <servlet.version>2.5</servlet.version>
        <wiser.version>1.2</wiser.version>

        <hibernate.dialect>org.hibernate.dialect.PostgreSQLDialect</hibernate.dialect>
        <jdbc.groupId>postgresql</jdbc.groupId>
        <jdbc.artifactId>postgresql</jdbc.artifactId>
        <jdbc.version>8.1-407.jdbc3</jdbc.version>
        <jdbc.driverClassName>org.postgresql.Driver</jdbc.driverClassName>
        <jdbc.url>jdbc:postgresql://localhost/${db.name}</jdbc.url>
        <jdbc.username>postgres</jdbc.username>
        <jdbc.password>dbms4Fna</jdbc.password>
        <search.index.basedir>${project.build.testOutputDirectory}</search.index.basedir>
    </properties>
</project>


persistence.xml

<?xml version="1.0" encoding="UTF-8"?>
<persistence xmlns="http://java.sun.com/xml/ns/persistence"
    version="1.0">
    <persistence-unit name="ApplicationEntityManager"
        transaction-type="RESOURCE_LOCAL">
        <provider>org.hibernate.ejb.HibernatePersistence</provider>
        <class>com.pcjavanet.model.User</class>
        <properties>
        <property name="hibernate.hbm2ddl.auto" value="create" /> 
<!--                 <property name="hibernate.hbm2ddl.auto" value="update" /> -->
            
            <property name="hibernate.show_sql" value="true" />
            <property name="hibernate.formate_sql" value="true" />
        </properties>
    </persistence-unit>
 
</persistence>   /**
     * {@inheritDoc}
     */
    public String getUserPassword(Long userId) {
        JdbcTemplate jdbcTemplate = new JdbcTemplate(dataSource);
        Table table = AnnotationUtils.findAnnotation(User.class, Table.class);
        return jdbcTemplate.queryForObject(
                "select password from " + table.name() + " where id=?", String.class, userId);
    }

pcjavanet
关注
专栏目录
谈谈 @Transactional 的原理和坑
Chenhui98的博客
08-16 749
Java 后端面试的时候，面试官经常会问到 @Transactional 的原理，以及容易踩的坑，之前一面百度，就遇到过，今天就带大家把这几块知识吃透。
spring事务（两种）
pycharm_u的博客
03-25 298
如果不配置事务，那么只有查询功能，其他不无法操作。 第一种：xml配置 <!-- 配置事物管理器 --> <bean id="txManager" class="org.springframework.orm.hibernate4.HibernateTransactionManager"> <property name="sessionFactory...
spring的两种事务管理方式
ke_mo_duo的博客
05-09 2266
编程式事务管理：    在实际开发中很少使用    通过TransactionTemplate手动管理事务。声明式事务管理(使用XML配置)：    开发中推荐使用(代码入侵性最小)    spring的声明式事务是通过AOP实现的未完待续。。。。...
spring项目中，通过applicationcontext.xml配置默认事务管理器
weixin_42792301的博客
03-09 813
<bean id="transactionManager" class="org.springframework.orm.jpa.JpaTransactionManager" primary="true"> </bean> 属性primary，布尔类型，值为true时，用于设定当前的事务管理器是默认（最优先匹配）。 一、背景 项目原本只有一个jpa的事务管理（用于数据库读...
Spring 之注解事务 @Transactional
奋斗、
10-17 4万+
先让我们看代码吧！ 以下代码为在“Spring3事务管理——基于tx/aop命名空间的配置”基础上修改。首先修改applicationContext.xml如下： ? 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18
浅谈Spring的两种事务定义方式
08-29
浅谈Spring的两种事务定义方式 Spring框架提供了两种事务定义方式：声明式和注解式。下面我们将深入探讨这两种方式的实现和应用。 声明式事务 声明式事务是通过在XML文件中定义需要拦截方法的匹配来完成配置的。...
spring 自定义事务管理器，编程式事务，声明式事务@Transactional使用
07-13
在Java应用中，Spring提供了两种主要的事务管理方式：编程式事务管理和声明式事务管理。 **编程式事务管理** 是通过调用`PlatformTransactionManager`接口提供的方法来手动控制事务的开始、提交、回滚。例如，你...
spring3.0两种事务管理配置
01-30
Spring 3.0 提供了两种事务管理配置方法：基于 XML 的事务管理和基于 @Transactional 的事务管理，这两种方法都是为了实现事务管理的目标，分别具有不同的配置方式和优缺点。 基于 XML 的事务管理 这种方法不需要...
Spring事务处理原理步骤详解
08-19
在Spring中，事务处理的实现主要通过两种方式：声明式事务和编程式事务。声明式事务是通过在方法上添加@Transactional注解来实现事务处理的，而编程式事务则是通过编写代码来实现事务处理的。 在声明式事务中，需要...
Spring三种事务测试实现.zip
06-03
Spring项目，数据库用mysql，整合Mybatis，需要自己创建数据库testinnodb，以及两张表Account，int id, int account，表Log，int id ,...三种事务，手动实现事务，利用AOP实现，以及声明式事务，lib中有所有的jar。
Idea编译Spring源码遇到的问题
qq_23727789的博客
11-18 5699
首先声明我的idea版本为Idea 2017.2 ,spring源码为5.2 ,Gradle版本我下了4.1, 5.4.1, 5.6.4三个版本,见下图: 其次gradle的环境变量已配置,见下图: 然后接下来,开始展示我所遇到的问题: 1,No such property: GradleVersion for class: JetGradlePlugin 此时我选择的是gra...
spring事物配置，声明式事务管理和基于@Transactional注解的使用
热门推荐
不学习就淘汰
12-04 30万+
事务管理对于企业应用来说是至关重要的，即使出现异常情况，它也可以保证数据的一致性。 spring支持编程式事务管理和声明式事务管理两种方式。 编程式事务管理使用TransactionTemplate或者直接使用底层的PlatformTransactionManager。对于编程式事务管理，spring推荐使用TransactionTemplate。  声明式事务管理建立在
Spring中sequence的使用小结
wang0928007的专栏
01-04 5775
1).简单介绍 sequence就是所谓的序列号，每次取的时候它会自动增加，一般用在需要按序列号排序的地方。 1、 create sequence 你首先要有create sequence或者create any sequence权限 create sequence emp_sequence INCREMENT BY 1 -- 每次加几个 START WITH 1 --
Spring的两种事务定义方式
和大黄的博客
06-23 8186
一、第一种配置方法：基于XML的事务管理 这种方法不需要对原有的业务做任何修改，通过在XML文件中定义需要拦截方法的匹配即可完成配置，要求是，业务处理中的方法的命名要有规律，比如setXxx，xxxUpdate等等。详细配置如下：
在Spring中配置使用Java Persistence API（JPA）
weixin_30902675的博客
02-29 181
1. 配置数据源 首先，在Spring配置文件(applicationContext.xml)中创建一个JNDI数据源，该数据源使用JndiObjectFactoryBean <bean id="dataSource" destroy-method="close" class="org.springframework.jndi.JndiObjectFactoryBean"&gt...
spring的两种常用事务传播属性说明
qianxiaopeng的专栏
09-18 1万+
常用的两种传播属性： 1.REQUIRED 如果存在当前事务则用当前事务，如果不存在当前事务，则新建一个事务 2.REQUIRES_NEW 如果当前存在事务则挂起当前事务，开启一个新事务，新事务执行完毕后，唤醒之前挂起的事务，继续执行。如果不存在当前事务，则新建一个事务 第一种情况： 执行controller以后事务会回滚，两条数都插不进去。（propagation如果不写默认的是...
Hibernate Search 的一些基础配置
shenpeihui的专栏
03-29 1330
1.Enabling Hibernate Search   默认Hibernate Core自动在classpath中查找运行。   设置hibernate.search.autoregister_listeners为false可以禁止此功能。   2.Automatic indexing   默认对象更新，插入，删除时自动索引(直接在数据库插入数据无效)
Spring 2.5 中配置 JPA
weixin_34409703的博客
01-24 116
翻译：SpringSide团队 转载请注明出处。 本文提供了一个简单的 Spring 框架 standalone 环境下，如何 step-by-step 去开发 JPA 的向导。 JPA 的规范最开始时是由 EJB 3.0 的持久性机制产生的， 它被公认为是把简单的 POJOs 持久化的机制。你只需少量 JAR 在 classpath 中，配置一点 Spring 的 bean， 就能在...
Spring事务管理：原理与五种配置方式解析
Spring事务管理有两种模式：编程式和声明式。 编程式事务管理允许开发者直接控制事务的开始、提交和回滚。这提供了最大的灵活性，但可能导致代码中事务管理逻辑的重复。`TransactionTemplate`是编程式事务的一个...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值