事务管理

一个数据库事务是三个纯净的干活单元操作体系。这个操作应该依旧完全地进行,要么完全不实施。事务管理是一个至关心珍视要组成都部队分,事务管理可以保证数据完整性和一致性。事务有着以下多少个十分重要性格分别是 ACID:

  • 原子性:事务应该作为三个单身单元的操作,那意味着整个连串操作照旧是打响,要么是没戏的。

  • 一致性:那意味着数据库的引用完整性的一致性,表中唯一的主键等。

  • 隔开分离性:大概同时处理很多有同样的数据集的事务,各类工作应该与别的工作隔断,防止备数据损坏。

  • 持久性:一个业务一旦完毕全部操作后,那个业务的结果必须是永久性的,不能够因系统故障而从数据库中删除。

2个的确的关系型数据库管理种类应该为各类工作保险拥有的多个特点。使用 SQL
公布到数据库中的事务的简短视图如下:

  • 使用 begin transactionXML, 命令起初事务。

  • 应用 SQL 查询语句执行各类删除、更新或插队操作。

  • 假定全数的操作都成功,则执行提交操作,否则回滚富有操作。

Spring 扶助理编辑程式和表明式事务管理。EJB 要求2个应用程序服务器,但 Spring
事务管理能够在不需求应用程序服务器的场合下促成。

 

编程式 vs. 声明式

Spring 扶助二种档次的事务管理:

  • 编制程序式事务管理
    :那表示你在编程的赞助下有管理作业。那给了你十分大的八面后珑,但却很难保险。

  • 申明式事务管理
    :那象征你从事情代码中分离事务管理。你只有使用评释或 XML
    配置来管理作业。

评释式事务管理比编程式事务管理更可取,就算它不比编程式事务管理灵活,但它同意你通过代码控制作业。但作为一种横切关怀点,注脚式事务管理能够运用
AOP 方法开始展览模块化。Spring 协理接纳 Spring AOP 框架的评释式事务管理。

 

Spring 事务抽象

Spring
事务抽象的关键是由 org.springframework.transaction.PlatformTransactionManager 接口定义,如下所示:

1 public interface PlatformTransactionManager {
2    TransactionStatus getTransaction(TransactionDefinition definition) throws TransactionException;
3    void commit(TransactionStatus status) throws TransactionException;
4    void rollback(TransactionStatus status) throws TransactionException;
5 }

TransactionStatus getTransaction(TransactionDefinition
definition):根据钦定的扩散行为,该办法重回当前活动工作或创办1个新的事情。

void commit(TransactionStatus
status):该措施提交给定的业务和有关它的地方。

void rollback(TransactionStatus status):该措施执行3个加以事务的回滚。

 

TransactionDefinition 是在 Spring 新疆中华工程公司作协理的中央接口,它的概念如下:

1 public interface TransactionDefinition {
2    int getPropagationBehavior();
3    int getIsolationLevel();
4    String getName();
5    int getTimeout();
6    boolean isReadOnly();
7 }

int getPropagationBehavior():该情势再次回到传播行为。Spring 提供了与 EJB
CMT 类似的有所的业务传播选项。

int getIsolationLevel():该方法重临该业务独立于别的作业的做事的水平。

String getName():该办法返回该业务的称谓。

int
getTimeout():该方法再次来到以秒为单位的年华间隔,事务必须在该时间距离内形成。

boolean isReadOnly():该办法再次回到该事务是否是只读的。

下边是隔开分离级其余可能值:

TransactionDefinition.ISOLATION_DEFAULT:那是暗中认可的隔离级别。

TransactionDefinition.ISOLATION_READ_COMMITTED:表明能够阻止误读;可以产生不可重复读和虚读。

TransactionDefinition.ISOLATION_READ_UNCOMMITTED:表明能够产生误读、不可重复读和虚读。

TransactionDefinition.ISOLATION_REPEATABLE_READ:评释能够阻挡误读和不足重复读;能够生出虚读。

TransactionDefinition.ISOLATION_SE奥迪Q7IALIZABLE:注明能够阻挡误读、不可重复读和虚读。

上面是流传类型的或是值:

TransactionDefinition.PROPAGATION_MANDATO福特ExplorerY:辅助当前业务;假诺不存在当前事务,则抛出1个要命。

TransactionDefinition.PROPAGATION_NESTED:即使存在当前工作,则在3个嵌套的政工中实践。

TransactionDefinition.PROPAGATION_NEVE昂科威:不扶助当前事情;假如存在当前政工,则抛出一个13分。

TransactionDefinition.PROPAGATION_NOT_SUPPOLacrosseTED:不帮忙当前业务;而连日执行非事务性。

TransactionDefinition.PROPAGATION_REQUIRED:匡助当前工作;借使不设有业务,则创立贰个新的事情。

TransactionDefinition.PROPAGATION_REQUIRES_NEW:创立二个新业务,假诺存在2个工作,则把当前作业挂起。

TransactionDefinition.PROPAGATION_SUPPO本田UR-VTS:帮助当前政工;假使不设有,则履行非事务性。

TransactionDefinition.TIMEOUT_DEFAULT:使用默许超时的底层工作系统,可能只要不支持过期则尚未。

 

TransactionStatus 接口为作业代码提供了叁个简短的法门来控制工作的执行和询问业务状态。

1 public interface TransactionStatus extends SavepointManager {
2    boolean isNewTransaction();
3    boolean hasSavepoint();
4    void setRollbackOnly();
5    boolean isRollbackOnly();
6    boolean isCompleted();
7 }

boolean
hasSavepoint():该形式重临该事情内部是还是不是有多个保存点,也即是说,基于二个保存点已经创建了嵌套事务。

boolean
isCompleted():该方法重返该业务是不是形成,也正是说,它是或不是业已交给或回滚。

boolean isNewTransaction():在当前工作是新的事态下,该格局重返 true。

boolean isRollbackOnly():该措施重返该事务是不是已标记为 rollback-only。

void setRollbackOnly():该办法设置该业务为 rollback-only 标记。

 

Spring 编制程序式事务管理

编制程序式事务管理方法允许你在对您的源代码编制程序的声援下管理工科作。那给了你非常的大地灵活性,可是它很难有限协助。

在大家起初以前,至少要有多少个数据库表,在业务的鼎力相助下大家得以实施多种CRUD 操作。以 Student 表为例,用下述 DDL 能够在 MySQL TEST
数据库中创制该表:

1 CREATE TABLE Student(
2    ID   INT NOT NULL AUTO_INCREMENT,
3    NAME VARCHAR(20) NOT NULL,
4    AGE  INT NOT NULL,
5    PRIMARY KEY (ID)
6 );

其次个表是 马科斯,用来储存基于年份的上学的儿童的符号。那里 SID 是 Student
表的外键。

1 CREATE TABLE Marks(
2    SID INT NOT NULL,
3    MARKS  INT NOT NULL,
4    YEAR   INT NOT NULL
5 );

让我们一贯选用 PlatformTransactionManager 来完成编制程序式方法从而达成业务。要从头叁个新业务,你需求有3个包含适当的
transaction
属性的 TransactionDefinition 的实例。这几个事例中,大家运用私下认可的
transaction 属性简单的创设了 DefaultTransactionDefinition 的三个实例。

当 TransactionDefinition
创设后,你能够通过调用 getTransaction() 方法来发轫你的事务,该方法会再次回到 TransactionStatus 的一个实例。 TransactionStatus 对象支持追踪当前的作业状态,并且最后,假若一切运维顺遂,你能够应用 PlatformTransactionManager 的 commit() 方法来交付这些业务,不然的话,你能够行使 rollback() 方法来回滚整个操作。

近来让大家编辑我们的 Spring JDBC 应用程序,它亦可在 Student 和 Mark表中完毕简单的操作。让大家正好的运用 Eclipse
IDE,并依据如下所示的步子来创立二个 Spring 应用程序:

手续一:创造2个名为 SpringExample 的品类,并在创立的类型中的 src 文件夹下创造包com.tutorialspoint

步骤二:使用 Add JARs 选项添加必需的 Spring 库。

步骤三:在档次中添加 Spring JDBC
钦命的最新的库 mysql-connector-java.jar,org.springframework.jdbc.jar 和 org.springframework.transaction.jar。假使没有这么些库,你能够下载它们。

步骤四:创建 DAO
接口 StudentDAO 并列出全体要求的不二法门。固然它不是必不可少的还要你能够直接编写 StudentJDBCTemplate 类,但是作为2个好的施行,大家依然做吧。

步骤五:在com.tutorialspoint包下创造别的须要的 Java
类 StudentMarksStudentMarksMapperStudentJDBCTemplate 和 MainApp。若是必要的话,你能够创制别的的
POJO 类。

步骤六:确定保障您早就在 TEST
数据库中创建了 Student 和 Marks 表。还要保证您的 MySQL
服务器运维平日并且你利用给出的用户名和密码能够读/写访问数据库。

手续七:在 src 文件夹下创设 Beans 配置文件 Beans.xml 。

最后一步:最终一步是创设全体 Java 文件和 Bean
配置文件的剧情并根据如下所示的办法运营应用程序。

下边是多少访问对象接口文件 StudentDAO.java 的始末:

 1 package com.tutorialspoint;
 2 import java.util.List;
 3 import javax.sql.DataSource;
 4 public interface StudentDAO {
 5    /** 
 6     * This is the method to be used to initialize
 7     * database resources ie. connection.
 8     */
 9    public void setDataSource(DataSource ds);
10    /** 
11     * This is the method to be used to create
12     * a record in the Student and Marks tables.
13     */
14    public void create(String name, Integer age, Integer marks, Integer year);
15    /** 
16     * This is the method to be used to list down
17     * all the records from the Student and Marks tables.
18     */
19    public List<StudentMarks> listStudents();
20 }

下边是 Student马科斯.java 文件的剧情:

 1 package com.tutorialspoint;
 2 public class StudentMarks {
 3    private Integer age;
 4    private String name;
 5    private Integer id;
 6    private Integer marks;
 7    private Integer year;
 8    private Integer sid;
 9    public void setAge(Integer age) {
10       this.age = age;
11    }
12    public Integer getAge() {
13       return age;
14    }
15    public void setName(String name) {
16       this.name = name;
17    }
18    public String getName() {
19       return name;
20    }
21    public void setId(Integer id) {
22       this.id = id;
23    }
24    public Integer getId() {
25       return id;
26    }
27    public void setMarks(Integer marks) {
28       this.marks = marks;
29    }
30    public Integer getMarks() {
31       return marks;
32    }
33    public void setYear(Integer year) {
34       this.year = year;
35    }
36    public Integer getYear() {
37       return year;
38    }
39    public void setSid(Integer sid) {
40       this.sid = sid;
41    }
42    public Integer getSid() {
43       return sid;
44    }
45 }

以下是 Student马科斯Mapper.java 文件的剧情:

 1 package com.tutorialspoint;
 2 import java.sql.ResultSet;
 3 import java.sql.SQLException;
 4 import org.springframework.jdbc.core.RowMapper;
 5 public class StudentMarksMapper implements RowMapper<StudentMarks> {
 6    public StudentMarks mapRow(ResultSet rs, int rowNum) throws SQLException {
 7       StudentMarks studentMarks = new StudentMarks();
 8       studentMarks.setId(rs.getInt("id"));
 9       studentMarks.setName(rs.getString("name"));
10       studentMarks.setAge(rs.getInt("age"));
11       studentMarks.setSid(rs.getInt("sid"));
12       studentMarks.setMarks(rs.getInt("marks"));
13       studentMarks.setYear(rs.getInt("year"));
14       return studentMarks;
15    }
16 }

上边是概念的 DAO 接口 StudentDAO 实现类公事 StudentJDBCTemplate.java:

 1 package com.tutorialspoint;
 2 import java.util.List;
 3 import javax.sql.DataSource;
 4 import org.springframework.dao.DataAccessException;
 5 import org.springframework.jdbc.core.JdbcTemplate;
 6 import org.springframework.transaction.PlatformTransactionManager;
 7 import org.springframework.transaction.TransactionDefinition;
 8 import org.springframework.transaction.TransactionStatus;
 9 import org.springframework.transaction.support.DefaultTransactionDefinition;
10 public class StudentJDBCTemplate implements StudentDAO {
11    private DataSource dataSource;
12    private JdbcTemplate jdbcTemplateObject;
13    private PlatformTransactionManager transactionManager;
14    public void setDataSource(DataSource dataSource) {
15       this.dataSource = dataSource;
16       this.jdbcTemplateObject = new JdbcTemplate(dataSource);
17    }
18    public void setTransactionManager(
19       PlatformTransactionManager transactionManager) {
20       this.transactionManager = transactionManager;
21    }
22    public void create(String name, Integer age, Integer marks, Integer year){
23       TransactionDefinition def = new DefaultTransactionDefinition();
24       TransactionStatus status = transactionManager.getTransaction(def);
25       try {
26          String SQL1 = "insert into Student (name, age) values (?, ?)";
27          jdbcTemplateObject.update( SQL1, name, age);
28          // Get the latest student id to be used in Marks table
29          String SQL2 = "select max(id) from Student";
30          int sid = jdbcTemplateObject.queryForInt( SQL2 );
31          String SQL3 = "insert into Marks(sid, marks, year) " + 
32                        "values (?, ?, ?)";
33          jdbcTemplateObject.update( SQL3, sid, marks, year);
34          System.out.println("Created Name = " + name + ", Age = " + age);
35          transactionManager.commit(status);
36       } catch (DataAccessException e) {
37          System.out.println("Error in creating record, rolling back");
38          transactionManager.rollback(status);
39          throw e;
40       }
41       return;
42    }
43    public List<StudentMarks> listStudents() {
44       String SQL = "select * from Student, Marks where Student.id=Marks.sid";
45       List <StudentMarks> studentMarks = jdbcTemplateObject.query(SQL, 
46                                          new StudentMarksMapper());
47       return studentMarks;
48    }
49 }

今后让我们转移主应用程序文件 MainApp.java,如下所示:

 1 package com.tutorialspoint;
 2 import java.util.List;
 3 import org.springframework.context.ApplicationContext;
 4 import org.springframework.context.support.ClassPathXmlApplicationContext;
 5 import com.tutorialspoint.StudentJDBCTemplate;
 6 public class MainApp {
 7    public static void main(String[] args) {
 8       ApplicationContext context = 
 9              new ClassPathXmlApplicationContext("Beans.xml");
10       StudentJDBCTemplate studentJDBCTemplate = 
11       (StudentJDBCTemplate)context.getBean("studentJDBCTemplate");     
12       System.out.println("------Records creation--------" );
13       studentJDBCTemplate.create("Zara", 11, 99, 2010);
14       studentJDBCTemplate.create("Nuha", 20, 97, 2010);
15       studentJDBCTemplate.create("Ayan", 25, 100, 2011);
16       System.out.println("------Listing all the records--------" );
17       List<StudentMarks> studentMarks = studentJDBCTemplate.listStudents();
18       for (StudentMarks record : studentMarks) {
19          System.out.print("ID : " + record.getId() );
20          System.out.print(", Name : " + record.getName() );
21          System.out.print(", Marks : " + record.getMarks());
22          System.out.print(", Year : " + record.getYear());
23          System.out.println(", Age : " + record.getAge());
24       }
25    }
26 }

下边是陈设文件 Beans.xml 的剧情:

 1 <?xml version="1.0" encoding="UTF-8"?>
 2 <beans xmlns="http://www.springframework.org/schema/beans"
 3     xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 
 4     xsi:schemaLocation="http://www.springframework.org/schema/beans
 5     http://www.springframework.org/schema/beans/spring-beans-3.0.xsd ">
 6 
 7    <!-- Initialization for data source -->
 8    <bean id="dataSource" 
 9       class="org.springframework.jdbc.datasource.DriverManagerDataSource">
10       <property name="driverClassName" value="com.mysql.jdbc.Driver"/>
11       <property name="url" value="jdbc:mysql://localhost:3306/TEST"/>
12       <property name="username" value="root"/>
13       <property name="password" value="password"/>
14    </bean>
15 
16    <!-- Initialization for TransactionManager -->
17    <bean id="transactionManager" 
18       class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
19       <property name="dataSource"  ref="dataSource" />    
20    </bean>
21 
22    <!-- Definition for studentJDBCTemplate bean -->
23    <bean id="studentJDBCTemplate"
24       class="com.tutorialspoint.StudentJDBCTemplate">
25       <property name="dataSource"  ref="dataSource" />
26       <property name="transactionManager"  ref="transactionManager" />    
27    </bean>
28 
29 </beans>

当你落成了创设源和 bean
配置文件后,让我们运维应用程序。要是您的应用程序运转顺遂的话,那么将会输出如下所示的新闻:

------Records creation--------
Created Name = Zara, Age = 11
Created Name = Nuha, Age = 20
Created Name = Ayan, Age = 25
------Listing all the records--------
ID : 1, Name : Zara, Marks : 99, Year : 2010, Age : 11
ID : 2, Name : Nuha, Marks : 97, Year : 2010, Age : 20
ID : 3, Name : Ayan, Marks : 100, Year : 2011, Age : 25

 

Spring 评释式事务管理

评释式事务管理方法允许你在布局的帮口疮而不是源代码硬编制程序来治本工作。那意味着你能够将事务管理从作业代码中隔绝出来。你能够只利用注释或依照配置的
XML 来治本事务。 bean 配置会钦赐事务型方法。那是与注明式事务相关的步骤:

  • 大家运用 标签,它创制2个事务处理的建议,同时,我们定义2个分外全数办法的切入点,我们盼望那个方法是事务型的还要会引用事务型的建议。

  • 假若在事务型配置中包括了一个方法的名称,那么创设的建议在调用方法此前就会在业务中初露展开。

  • 对象方法会在 try / catch 块中执行。

  • 倘使艺术平常结束,AOP 提议会成功的付出业务,不然它实施回滚操作。

让我们看看上述手续是什么促成的。不过在我们开始以前,至少有七个数据库表是相当重要的,在工作的帮助下,我们得以兑现各样CRUD 操作。以 Student 表为例,该表是利用下述 DDL 在 MySQL TEST
数据库中开创的。

1 CREATE TABLE Student(
2    ID   INT NOT NULL AUTO_INCREMENT,
3    NAME VARCHAR(20) NOT NULL,
4    AGE  INT NOT NULL,
5    PRIMARY KEY (ID)
6 );

首个表是 马科斯,我们用来存款和储蓄基于年份的学生标记。在此处,SID 是 Student
表的外键。

1 CREATE TABLE Marks(
2    SID INT NOT NULL,
3    MARKS  INT NOT NULL,
4    YEAR   INT NOT NULL
5 );

近年来让大家编辑 Spring JDBC 应用程序来在 Student 和 马科斯表中落到实处不难的操作。让大家正好的选取 Eclipse
IDE,并遵守如下所示的步骤来成立四个 Spring 应用程序:

步骤一:创设二个名为 SpringExample 的品类,并在开立的类型中的 src 文件夹下创设包 com.tutorialspoint

步骤二:使用 Add JARs 选项添加必需的 Spring 库。

步骤三:在类型中添加别的必需的库 mysql-connector-java.jar,org.springframework.jdbc.jar 和 org.springframework.transaction.jar。假若你还不曾那一个库,你能够下载它们。

步骤四:创建 DAO
接口 StudentDAO 并列出富有须要的点子。即便它不是必不可少的还要你能够间接编写 StudentJDBCTemplate 类,然而作为四个好的施行,大家依旧做吗。

步骤五:在 com.tutorialspoint 包下创办其余须求的 Java
类 StudentMarksStudentMarksMapperStudentJDBCTemplate 和 MainApp。假设须要的话,你能够成立别的的
POJO 类。

手续六:确定保障您曾经在 TEST
数据库中开创了 Student 和 马科斯 表。还要保证您的 MySQL
服务器运营如常并且你利用给出的用户名和密码能够读/写访问数据库。

手续七:在 src 文件夹下成立 Beans 配置文件 Beans.xml 。

最后一步:最后一步是开创全数 Java 文件和 Bean
配置文件的始末并遵照如下所示的措施运转应用程序。

下边是数量访问对象接口文件 StudentDAO.java 的内容:

 1 package com.tutorialspoint;
 2 import java.util.List;
 3 import javax.sql.DataSource;
 4 public interface StudentDAO {
 5    /** 
 6     * This is the method to be used to initialize
 7     * database resources ie. connection.
 8     */
 9    public void setDataSource(DataSource ds);
10    /** 
11     * This is the method to be used to create
12     * a record in the Student and Marks tables.
13     */
14    public void create(String name, Integer age, Integer marks, Integer year);
15    /** 
16     * This is the method to be used to list down
17     * all the records from the Student and Marks tables.
18     */
19    public List<StudentMarks> listStudents();
20 }

以下是 Student马科斯.java 文件的内容:

 1 package com.tutorialspoint;
 2 public class StudentMarks {
 3    private Integer age;
 4    private String name;
 5    private Integer id;
 6    private Integer marks;
 7    private Integer year;
 8    private Integer sid;
 9    public void setAge(Integer age) {
10       this.age = age;
11    }
12    public Integer getAge() {
13       return age;
14    }
15    public void setName(String name) {
16       this.name = name;
17    }
18    public String getName() {
19       return name;
20    }
21    public void setId(Integer id) {
22       this.id = id;
23    }
24    public Integer getId() {
25       return id;
26    }
27    public void setMarks(Integer marks) {
28       this.marks = marks;
29    }
30    public Integer getMarks() {
31       return marks;
32    }
33    public void setYear(Integer year) {
34       this.year = year;
35    }
36    public Integer getYear() {
37       return year;
38    }
39    public void setSid(Integer sid) {
40       this.sid = sid;
41    }
42    public Integer getSid() {
43       return sid;
44    }
45 }

上面是 Student马科斯Mapper.java 文件的始末:

 1 package com.tutorialspoint;
 2 import java.sql.ResultSet;
 3 import java.sql.SQLException;
 4 import org.springframework.jdbc.core.RowMapper;
 5 public class StudentMarksMapper implements RowMapper<StudentMarks> {
 6    public StudentMarks mapRow(ResultSet rs, int rowNum) throws SQLException {
 7       StudentMarks studentMarks = new StudentMarks();
 8       studentMarks.setId(rs.getInt("id"));
 9       studentMarks.setName(rs.getString("name"));
10       studentMarks.setAge(rs.getInt("age"));
11       studentMarks.setSid(rs.getInt("sid"));
12       studentMarks.setMarks(rs.getInt("marks"));
13       studentMarks.setYear(rs.getInt("year"));
14       return studentMarks;
15    }
16 }

上边是概念的 DAO 接口 StudentDAO 实现类公事 StudentJDBCTemplate.java:

 1 package com.tutorialspoint;
 2 import java.util.List;
 3 import javax.sql.DataSource;
 4 import org.springframework.dao.DataAccessException;
 5 import org.springframework.jdbc.core.JdbcTemplate;
 6 public class StudentJDBCTemplate implements StudentDAO{
 7    private JdbcTemplate jdbcTemplateObject;
 8    public void setDataSource(DataSource dataSource) {
 9       this.jdbcTemplateObject = new JdbcTemplate(dataSource);
10    }
11    public void create(String name, Integer age, Integer marks, Integer year){
12       try {
13          String SQL1 = "insert into Student (name, age) values (?, ?)";
14          jdbcTemplateObject.update( SQL1, name, age);
15          // Get the latest student id to be used in Marks table
16          String SQL2 = "select max(id) from Student";
17          int sid = jdbcTemplateObject.queryForInt( SQL2 );
18          String SQL3 = "insert into Marks(sid, marks, year) " + 
19                        "values (?, ?, ?)";
20          jdbcTemplateObject.update( SQL3, sid, marks, year);
21          System.out.println("Created Name = " + name + ", Age = " + age);
22          // to simulate the exception.
23          throw new RuntimeException("simulate Error condition") ;
24       } catch (DataAccessException e) {
25          System.out.println("Error in creating record, rolling back");
26          throw e;
27       }
28    }
29    public List<StudentMarks> listStudents() {
30       String SQL = "select * from Student, Marks where Student.id=Marks.sid";
31       List <StudentMarks> studentMarks=jdbcTemplateObject.query(SQL, 
32       new StudentMarksMapper());
33       return studentMarks;
34    }
35 }

近来让大家改变主应用程序文件 MainApp.java,如下所示:

 1 package com.tutorialspoint;
 2 import java.util.List;
 3 import org.springframework.context.ApplicationContext;
 4 import org.springframework.context.support.ClassPathXmlApplicationContext;
 5 public class MainApp {
 6    public static void main(String[] args) {
 7       ApplicationContext context = 
 8              new ClassPathXmlApplicationContext("Beans.xml");
 9       StudentDAO studentJDBCTemplate = 
10       (StudentDAO)context.getBean("studentJDBCTemplate");     
11       System.out.println("------Records creation--------" );
12       studentJDBCTemplate.create("Zara", 11, 99, 2010);
13       studentJDBCTemplate.create("Nuha", 20, 97, 2010);
14       studentJDBCTemplate.create("Ayan", 25, 100, 2011);
15       System.out.println("------Listing all the records--------" );
16       List<StudentMarks> studentMarks = studentJDBCTemplate.listStudents();
17       for (StudentMarks record : studentMarks) {
18          System.out.print("ID : " + record.getId() );
19          System.out.print(", Name : " + record.getName() );
20          System.out.print(", Marks : " + record.getMarks());
21          System.out.print(", Year : " + record.getYear());
22          System.out.println(", Age : " + record.getAge());
23       }
24    }
25 }

以下是布署文件 Beans.xml 的始末:

 1 <?xml version="1.0" encoding="UTF-8"?>
 2 <beans xmlns="http://www.springframework.org/schema/beans"
 3    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
 4    xmlns:tx="http://www.springframework.org/schema/tx"
 5    xmlns:aop="http://www.springframework.org/schema/aop"
 6    xsi:schemaLocation="http://www.springframework.org/schema/beans
 7    http://www.springframework.org/schema/beans/spring-beans-3.0.xsd 
 8    http://www.springframework.org/schema/tx
 9    http://www.springframework.org/schema/tx/spring-tx-3.0.xsd
10    http://www.springframework.org/schema/aop
11    http://www.springframework.org/schema/aop/spring-aop-3.0.xsd">
12 
13    <!-- Initialization for data source -->
14    <bean id="dataSource" 
15       class="org.springframework.jdbc.datasource.DriverManagerDataSource">
16       <property name="driverClassName" value="com.mysql.jdbc.Driver"/>
17       <property name="url" value="jdbc:mysql://localhost:3306/TEST"/>
18       <property name="username" value="root"/>
19       <property name="password" value="cohondob"/>
20    </bean>
21 
22    <tx:advice id="txAdvice"  transaction-manager="transactionManager">
23       <tx:attributes>
24       <tx:method name="create"/>
25       </tx:attributes>
26    </tx:advice>
27 
28    <aop:config>
29       <aop:pointcut id="createOperation" 
30       expression="execution(* com.tutorialspoint.StudentJDBCTemplate.create(..))"/>
31       <aop:advisor advice-ref="txAdvice" pointcut-ref="createOperation"/>
32    </aop:config>
33 
34    <!-- Initialization for TransactionManager -->
35    <bean id="transactionManager"
36    class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
37       <property name="dataSource"  ref="dataSource" />    
38    </bean>
39 
40    <!-- Definition for studentJDBCTemplate bean -->
41    <bean id="studentJDBCTemplate"  
42    class="com.tutorialspoint.StudentJDBCTemplate">
43       <property name="dataSource"  ref="dataSource" />  
44    </bean>
45 
46 </beans>

当你成功了创制源和 bean
配置文件后,让我们运维应用程序。假如你的应用程序运营顺遂的话,那么会输出如下所示的万分。在那种情形下,事务会回滚并且在数据库表中不会创造任何笔录。

------Records creation--------
Created Name = Zara, Age = 11
Exception in thread "main" java.lang.RuntimeException: simulate Error condition

在剔除StudentJDBCTemplate类中create方法抛出13分的代码后,你能够品尝上述示范,在这种景况下,会付出业务并且你可以在数据库中看见记录。

 

只顾:项目jar包如图所示,个中也暗含了Spring其它地点的有个别jar包,小Alan偷一下懒就没去剔除了,这一块我们能够尝试只留下供给的jar包,以便熟稔Spring所富含的各样jar包在类型中所可以起到的功效,记得把jar包引入项目中才能够运营上述的演示。

XML 1

 

 

结语:除了无可奈啥地点走向没落,没有人了然后边将会产生什么样,没有人。

 

可爱博主:AlanLee

博客地址:http://www.cnblogs.com/AlanLee

本文来源新浪,欢迎大家投入博客园。

 

相关文章

网站地图xml地图