95992828九五至尊2

Spring事务管理入门与进阶882828九五至尊手机版

二月 8th, 2019  |  882828九五至尊手机版

事务管理

一个数据库事务是一个纯粹的干活单元操作种类。那个操作应该仍旧完全地推行,要么完全不执行。事务管理是一个根本组成部分,事务管理可以有限支撑数据完整性和一致性。事务有着以下两个首要特性分别是 ACID:

  • 原子性:事务应该作为一个独立单元的操作,那代表任何种类操作依旧是马到功成,要么是败退的。

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

  • 隔离性:可能同时处理很多有同样的数据集的事务,每个业务应该与别的作业隔离,避防止数据损坏。

  • 持久性:一个政工一旦形成全套操作后,那一个工作的结果必须是永久性的,不可以因系统故障而从数据库中去除。

一个当真的关系型数据库管理体系应该为每个事情有限辅助拥有的多少个性状。使用 SQL
宣布到数据库中的事务的简单视图如下:

  • 使用 begin transaction 命令开端作业。

  • 选择 SQL 查询语句执行种种删除、更新或插队操作。

  • 只要拥有的操作都成功,则履行提交操作,否则回滚具备操作。

Spring 协理编程式和申明式事务管理。EJB 需求一个应用程序服务器,但 Spring
事务管理可以在不须要应用程序服务器的图景下促成。

 

Spring事务管理入门与进阶,spring事务进阶

编程式 vs. 声明式

Spring 帮衬三种档次的事务管理:

  • 编程式事务管理
    :那意味你在编程的助手下有管理作业。那给了你极大的八面驶风,但却很难有限协理。

  • 表明式事务管理
    :这代表你从工作代码中分离事务管理。你唯有使用申明或 XML
    配置来治本业务。

注解式事务管理比编程式事务管理更可取,即便它不如编程式事务管理灵活,但它同意你通过代码控制工作。但作为一种横切关切点,声明式事务管理可以应用
AOP 方法举办模块化。Spring 扶助采用 Spring AOP 框架的评释式事务管理。

 

事务管理

一个数据库事务是一个纯粹的工作单元操作种类。这个操作应该仍然完全地履行,要么完全不执行。事务管理是一个第一组成部分,事务管理可以保障数据完整性和一致性。事务有着以下多少个至关紧要特性分别是 ACID:

  • 原子性:事务应该作为一个独门单元的操作,那意味任何连串操作照旧是马到成功,要么是失利的。

  • 一致性:那表示数据库的引用完整性的一致性,表中绝无仅有的主键等。

  • 隔离性:可能同时处理很多有同等的数据集的政工,每个工作应该与任何工作隔离,以防患数据损坏。

  • 持久性:一个事务一旦已毕所有操作后,那一个业务的结果必须是永久性的,不可能因系统故障而从数据库中除去。

一个当真的关系型数据库管理种类应该为各类事情保障所有的五个特色。使用 SQL
发表到数据库中的事务的简便视图如下:

  • 使用 begin transaction 命令伊始作业。

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

  • 只要所有的操作都成功,则执行提交操作,否则回滚享有操作。

Spring 扶助编程式和表明式事务管理。EJB 须要一个应用程序服务器,但 Spring
事务管理可以在不必要应用程序服务器的意况下落成。

 

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):依据指定的流传行为,该办法再次回到当前移动工作或创办一个新的事务。

void commit(TransactionStatus
status):该办法提交给定的工作和关于它的景况。

void rollback(TransactionStatus status):该方法执行一个加以事务的回滚。

 

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_SERIALIZABLE:阐明能够阻挡误读、不可重复读和虚读。

上面是传播类型的或许值:

TransactionDefinition.PROPAGATION_MANDATORY:帮衬当前事务;倘使不设有当前事情,则抛出一个老大。

TransactionDefinition.PROPAGATION_NESTED:假设存在当前作业,则在一个嵌套的事务中执行。

TransactionDefinition.PROPAGATION_NEVER:不帮助当前政工;要是存在当前政工,则抛出一个卓殊。

TransactionDefinition.PROPAGATION_NOT_SUPPORTED:不支持当前业务;而连日执行非事务性。

TransactionDefinition.PROPAGATION_REQUIRED:协助当前政工;即使不存在工作,则开创一个新的工作。

TransactionDefinition.PROPAGATION_REQUIRES_NEW:创立一个新业务,即使存在一个事情,则把当前事情挂起。

TransactionDefinition.PROPAGATION_SUPPORTS:协助当前作业;如果不设有,则举办非事务性。

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 标记。

 

编程式 vs. 声明式

Spring 匡助两种类型的事务管理:

  • 编程式事务管理
    :那代表你在编程的支援下有管理作业。那给了您极大的布帆无恙,但却很难有限支持。

  • 注解式事务管理
    :那代表你从业务代码中分别事务管理。你偏偏使用表明或 XML
    配置来保管事务。

申明式事务管理比编程式事务管理更可取,即使它不如编程式事务管理灵活,但它同意你通过代码控制作业。但作为一种横切关怀点,声明式事务管理可以选取AOP 方法开展模块化。Spring 扶助接纳 Spring AOP 框架的申明式事务管理。

 

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 来落成编程式方法从而达成工作。要从头一个新业务,你须求有一个富含适当的
transaction
属性的 TransactionDefinition 的实例。这一个事例中,我们应用默许的
transaction 属性简单的开创了 DefaultTransactionDefinition 的一个实例。

当 TransactionDefinition
创造后,你可以由此调用 getTransaction() 方法来初步你的政工,该方法会重返 TransactionStatus 的一个实例。 TransactionStatus 对象辅助追踪当前的工作状态,并且最后,假使一切运行顺遂,你可以行使 PlatformTransactionManager 的 commit() 方法来交付那个事情,否则的话,你可以利用 rollback() 方法来回滚整个操作。

现今让大家编辑大家的 Spring JDBC 应用程序,它亦可在 Student 和 Mark表中落到实处不难的操作。让大家正好的选拔 Eclipse
IDE,并听从如下所示的步骤来创建一个 Spring 应用程序:

步骤一:创设一个名为 SpringExample 的项目,并在开创的品种中的 src 文件夹下创造包com.tutorialspoint

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

步骤三:在项目中添加 Spring JDBC
指定的风行的库 mysql-connector-java.jar,org.springframework.jdbc.jar 和 org.springframework.transaction.jar。如果没有这个库,你可以下载它们。

步骤四:创建 DAO
接口 StudentDAO 并列出所有要求的办法。就算它不是要求的同时你可以平昔编写 StudentJDBCTemplate 类,可是作为一个好的履行,我们如故做吧。

步骤五:在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 }

下边是 StudentMarks.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 事务抽象

Spring
事务抽象的重倘若由 882828九五至尊手机版,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):根据指定的传入行为,该方法重回当前移动工作或创设一个新的工作。

void commit(TransactionStatus
status):该办法提交给定的事情和有关它的景色。

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

 

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
get提姆eout():该措施再次回到以秒为单位的时刻间隔,事务必须在该时间距离内到位。

boolean isReadOnly():该方法再次回到该工作是不是是只读的。

上边是与世隔膜级其余也许值:

TransactionDefinition.ISOLATION_DEFAULT:那是默许的割裂级别。

TransactionDefinition.ISOLATION_READ_COMMITTED:注解可以阻止误读;可以暴发不可重复读和虚读。

TransactionDefinition.ISOLATION_READ_UNCOMMITTED:评释可以爆发误读、不可重复读和虚读。

TransactionDefinition.ISOLATION_REPEATABLE_READ:注明可以堵住误读和不可重复读;可以暴发虚读。

TransactionDefinition.ISOLATION_SERIALIZABLE:声明可以堵住误读、不可重复读和虚读。

上边是传播类型的或是值:

TransactionDefinition.PROPAGATION_MANDATORY:帮衬当前事情;要是不设有当前政工,则抛出一个老大。

TransactionDefinition.PROPAGATION_NESTED:倘若存在当前作业,则在一个嵌套的业务中履行。

TransactionDefinition.PROPAGATION_NEVER:不帮忙当前作业;假设存在当前业务,则抛出一个丰盛。

TransactionDefinition.PROPAGATION_NOT_SUPPORTED:不帮忙当前工作;而连日执行非事务性。

TransactionDefinition.PROPAGATION_REQUIRED:匡助当前事情;假设不设有业务,则开创一个新的事务。

TransactionDefinition.PROPAGATION_REQUIRES_NEW:创立一个新工作,假如存在一个政工,则把近日工作挂起。

TransactionDefinition.PROPAGATION_SUPPORTS:协理当前政工;假设不设有,则执行非事务性。

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 注明式事务管理

评释式事务管理方法允许你在配置的增援下而不是源代码硬编程来管理工作。那意味着你可以将事务管理从业务代码中隔离出来。你可以只利用注释或基于配置的
XML 来治本事务。 bean 配置会指定事务型方法。那是与注明式事务相关的步调:

  • 我们选取 标签,它创造一个事务处理的指出,同时,我们定义一个金童玉女所有办法的切入点,我们期望那么些艺术是事务型的还要会引用事务型的提出。

  • 如若在事务型配置中隐含了一个主意的名号,那么创立的提出在调用方法此前就会在事情中初始开展。

  • 对象方法会在 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 和 Marks表中落实不难的操作。让大家正好的行使 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方法抛出分外的代码后,你能够品尝上述示范,在那种情景下,会付出业务并且你可以在数据库中看见记录。

 

留神:项目jar包如图所示,其中也饱含了Spring其它地点的一对jar包,小Alan偷一下懒就没去剔除了,这一块我们能够尝尝只留下要求的jar包,以便熟谙Spring所蕴藏的每个jar包在项目中所可以起到的成效,记得把jar包引入项目中才可以运转上述的示范。

882828九五至尊手机版 1

 

 

结语:除了无可奈什么地点走向没落,没有人通晓前边将会时有暴发什么样,没有人。

 

可爱博主:AlanLee

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

正文来源天涯论坛,欢迎我们进入天涯论坛。

 

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 来落成编程式方法从而完结业务。要初始一个新工作,你要求有一个带有适当的
transaction
属性的 TransactionDefinition 的实例。这几个例子中,大家拔取默许的
transaction 属性不难的创立了 DefaultTransactionDefinition 的一个实例。

当 TransactionDefinition
创造后,你可以通过调用 getTransaction() 方法来初叶你的事体,该方法会重返 TransactionStatus 的一个实例。 TransactionStatus 对象帮助追踪当前的事景况态,并且最后,若是所有运行顺遂,你可以利用 PlatformTransactionManager 的 commit() 方法来交给那些事情,否则的话,你能够动用 rollback() 方法来回滚整个操作。

当今让我们编辑大家的 Spring JDBC 应用程序,它亦可在 Student 和 Mark表中贯彻不难的操作。让大家正好的行使 Eclipse
IDE,并遵守如下所示的手续来创建一个 Spring 应用程序:

步骤一:成立一个名为 SpringExample 的门类,并在开立的门类中的 src 文件夹下创造包com.tutorialspoint

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

手续三:在品种中添加 Spring JDBC
指定的摩登的库 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 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 配置会指定事务型方法。那是与评释式事务相关的步骤:

  • 大家接纳 标签,它成立一个事务处理的提出,同时,大家定义一个万分所有办法的切入点,大家盼望这么些格局是事务型的同时会引用事务型的提出。

  • 假诺在事务型配置中带有了一个办法的名目,那么创设的提议在调用方法从前就会在事情中开首举行。

  • 对象方法会在 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方法抛出万分的代码后,你可以品味上述示范,在那种景况下,会交到业务并且你可以在数据库中看见记录。

 

注意:项目jar包如图所示,其中也隐含了Spring其余方面的有的jar包,小Alan偷一下懒就没去剔除了,这一块大家能够品尝只留下须求的jar包,以便熟识Spring所包涵的每个jar包在品种中所可以起到的法力,记得把jar包引入项目中才可以运转上述的示范。

882828九五至尊手机版 2

 

 

结语:除了无可奈啥地点走向衰落,没有人知道前边将会生出哪些,没有人。

 

可爱博主:AlanLee

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

正文来源博客园,欢迎大家参预博客园。

 

http://www.bkjia.com/Javabc/1244000.htmlwww.bkjia.comtruehttp://www.bkjia.com/Javabc/1244000.htmlTechArticleSpring事务管理入门与进阶,spring事务进阶 事务管理
一个数据库事务是一个纯净的做事单元操作连串。这么些操作应该仍旧完全地执行,要么…

相关文章

Your Comments

近期评论

    功能


    网站地图xml地图