Spring 深入浅出核心技术(三)

最新推荐文章于 2023-03-24 16:35:45 发布
最新推荐文章于 2023-03-24 16:35:45 发布
阅读量262 收藏
点赞数
分类专栏： Spring 文章标签： spring

Spring JDBC

Spring JDBC简介

      我们早期都有过直接使用JDBC访问数据库的经历，开发者需要编写获取数据库连接，处理异常，释放资源，数据操作等代码。即使很简单的数据库操作，都需要很繁琐的编写。Spring JDBC通过模板和回调机制大大降低了JDBC的繁琐程度，我们仅需编写那些必不可少的数据操作代码就可以完成操作。

Spring模板和回调机制

      在直接使用JDBC时。我们需要处理获取连接，处理异常、释放资源等整个流程。Spring为支持的持久化技术提供了模板访问的方式，我们只需要提供具体的操作数据代码即可，可以大幅度提高开发效率。

      Spring将相同的数据访问流程固定到模板类中，例如，获取连接、释放资源等等。将数据库操作中固定和变化的部分分开，同时保证模板类线程安全，以便多个线程共享同一模块实例。固定的部分在模板类中已经写好，变化的部分通过回调接口开放出来，用于具体的数据访问和结果处理操作。

Spring为各种支持的持久化技术都提供了简化操作的模板和回调。例如为传统的JDBC提供了JdbcTemplate模块类，为Hibernate提供了HibernateTemplate模板类等等很多。我们直接使用即可。

Spring JDBC入门例子

不论使用任何持久化技术，都必须拥有数据库连接。在Spring中，我们需要配置数据库连接池来获取连接。我们的代码中都统一使用c3p0连接池。 

首先我们要先导包，我们需要导入spring的核心四个包和jdbc包和tx包(事务操作)，然后还需要导入c3p0包和数据库驱动等

我们创建一个数据库和数据表来进行演示 
CREATE DATABASE springdb;
USE springdb;
CREATE TABLE USER(
    id INT PRIMARY KEY AUTO_INCREMENT,
    username VARCHAR(50),
    PASSWORD VARCHAR(50)        
); 

INSERT INTO USER(username,PASSWORD) VALUES('张三','123456');
我们来演示一下怎么使用JdbcTemplate 
public class TestJdbc { 
    @Test
    public void test() throws Exception{ 
        //创建c3p0连接池，并设置相应的数据库参数
        ComboPooledDataSource datasource=new ComboPooledDataSource();
        datasource.setDriverClass("com.mysql.jdbc.Driver"); 
        datasource.setJdbcUrl("jdbc:mysql://localhost:3306/springdb");
        datasource.setUser("root");
        datasource.setPassword("123456");

        //创建JdbcTemplate对数据库进行操作
        JdbcTemplate template=new JdbcTemplate(datasource);
        String sql="insert into user(username,password) values(?,?)";
        template.update(sql, "李四","456789");
    }

}

这里写图片描述

详解JdbcTemplate

JdbcTemplate模板类几乎可以完成任何数据访问的操作，并且非常方便简介。我们上面的例子都是手动通过API 来创建连接池，来创建JdbcTemplate，我们完全可以使用我们学习的IoC来使用配置文件来替代那些操作，这也是我们所提倡的。

使用配置文件 

我们在Dao中使用Jdbctemplate,JdbcTemplate直接在配置文件中配置好，直接在Dao中注入即可。 

//我们先创建一个实体类
public class User {
    private int id;
    private String username;
    private String password;
    public int getId() {
        return id;
    }
    public void setId(int id) {
        this.id = id;
    }
    public String getUsername() {
        return username;
    }
    public void setUsername(String username) {
        this.username = username;
    }
    public String getPassword() {
        return password;
    }
    public void setPassword(String password) {
        this.password = password;
    }
    @Override
    public String toString() {
        return "User [id=" + id + ", username=" + username + ", password=" + password + "]";
    }

}
//创建Dao来对数据进行操作
public class UserDao { 
    //提供JdbcTemplate和set方法来进行注入
    private JdbcTemplate template;

    public void setTemplate(JdbcTemplate template) {
        this.template = template;
    }

    //更新方法
    public void update(User user){
        String sql="update  user set username=?,password=?  where id=?";
        Object []params={user.getUsername(),user.getPassword(),user.getId()};
        template.update(sql, params);
    }
}
<!--编写配置文件-->
<?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:aop="http://www.springframework.org/schema/aop"
    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.xsd
        http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop.xsd"> 

<!--配置连接池-->
<bean id="datasource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
    <property name="driverClass" value="com.mysql.jdbc.Driver"></property>
    <property name="jdbcUrl" value="jdbc:mysql://localhost:3306/springdb"></property>
    <property name="user" value="root"></property>
    <property name="password" value="123456"></property>
</bean>  

<!--实例JdbcTemplate，并且通过dataSource属性注入连接池-->
<bean id="jdbctemplate" class="org.springframework.jdbc.core.JdbcTemplate">
    <property name="dataSource" ref="datasource"></property>
</bean> 

<!--实例化Dao，并注入JdbcTemplate-->
<bean id="userdao" class="com.spring.jdbc.UserDao">
    <property name="template" ref="jdbctemplate"></property>
</bean>
</beans>     
//我们来测试一下
public class TestJdbc {     
    @Test
    public void test() throws Exception{
        ApplicationContext ac=new ClassPathXmlApplicationContext("bean.xml");
        UserDao userdao=(UserDao) ac.getBean("userdao");
        User user=new User();
        user.setId(1);
        user.setUsername("王五");
        user.setPassword("888888");
        userdao.update(user);
    }
}

这里写图片描述

使用属性文件配置数据库信息
数据库的配置信息有可能需要经常改动，所以一般将数据库配置信息放在属性文件中。 

//创建一个属性文件，名为jdbc.properties 

driverClass=com.mysql.jdbc.Driver
jdbcUrl=jdbc:mysql://localhost:3306/springdb
user=root
password=123456
<!--引入属性文件，以${xxx}的方式引入属性-->
<context:property-placeholder location="jdbc.properties"/>
<bean id="datasource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
    <property name="driverClass" value="${driverClass}"></property>
    <property name="jdbcUrl" value="${jdbcUrl}"></property>
    <property name="user" value="${user}"></property>
    <property name="password" value="${password}"></property>
</bean>

JdbcDaoSupport

我们的Dao层使用JdbcTemplate都需要提供一个JdbcTemplate属性和set方法来进行注入，而Spring为我们提供了一个父类JdbcDaoSupport，已经帮我们做好了这些操作。

//我们的Dao继承JdbcDaoSupport
public class UserDao extends JdbcDaoSupport{

    public void update(User user){
        String sql="update  user set username=?,password=?  where id=?";
        Object []params={user.getUsername(),user.getPassword(),user.getId()};
        this.getJdbcTemplate().update(sql, params);
    }
}   
//更改配置文件
<?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:aop="http://www.springframework.org/schema/aop"
    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.xsd
        http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop.xsd">

<bean id="datasource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
    <property name="driverClass" value="com.mysql.jdbc.Driver"></property>
    <property name="jdbcUrl" value="jdbc:mysql://localhost:3306/springdb"></property>
    <property name="user" value="root"></property>
    <property name="password" value="123456"></property>
</bean> 

<!--只需要将连接池给它，父类会自动帮我们创建JdbcTemplate-->
<bean id="userdao" class="com.spring.jdbc.UserDao">
    <property name="dataSource" ref="datasource"></property>
</bean>
</beans>

批量更改数据

如果需要一次性插入或更新多条记录，我们可以使用JdbcTemplate提供的批量操作的方法。

  • int[] batchUpdate(String []sql):多条不带参数的sql语句组成一个数组，该方法以批量方式执行这些sql语句，底层使用JDBC提供的批量操作的API。

  • int[] batchUpdate(String sql,BatchPreparedStatementSetter pss):使用本方法对带参sql语句进行多次数据更新操作，通过BatchPreparedStatementSetter回调接口进行批量参数的绑定工作。该接口定义了两个方法。

             -int  getBatchSize():指定本批次的大小
         -void setValues(PreparedStatement ps,int i):为给定的PreparedStatement设置参数 




    //我们为我们的Dao添加一个添加班级的操作，一次性插入多个User
public void addClass(final List<User> l){
        String sql="insert into user(username,password) values(?,?)"; 
        //执行批量操作
        template.batchUpdate(sql, new BatchPreparedStatementSetter() {

            //绑定插入的参数
            public void setValues(PreparedStatement ps, int index) throws SQLException {
                User user=l.get(index);
                ps.setString(1, user.getUsername());
                ps.setString(2, user.getPassword());
            }

            public int getBatchSize() {
                return l.size();
            }
        });
    }
    




    //我们来进行测试一下
public class TestJdbc {     
    @Test
    public void test() throws Exception{
        ApplicationContext ac=new ClassPathXmlApplicationContext("bean.xml");
        UserDao userdao=(UserDao) ac.getBean("userdao");
        List<User> list=new ArrayList<User>();
        User user1=new User();
        user1.setUsername("孙悟空");
        user1.setPassword("123");
        User user2=new User();
        user2.setUsername("猪八戒");
        user2.setPassword("456");
        list.add(user1);
        list.add(user2);
        userdao.addClass(list);
    }
}

    


    这里写图片描述 
    


    查询所有数据
    




        //Spring提供了RowMapper<T>接口来处理结果集，有很多实现类，我们使用BeanPropertyRowMapper
    public List<User> selectAll(){
        String sql="select * from user";
        return template.query(sql,BeanPropertyRowMapper.newInstance(User.class));
    }
    




    //我们测试一下
public class TestJdbc {     
    @Test
    public void test() throws Exception{
        ApplicationContext ac=new ClassPathXmlApplicationContext("bean.xml");
        UserDao userdao=(UserDao) ac.getBean("userdao");
        List<User> list=userdao.selectAll();
        for(User u:list){
            System.out.println(u);
        }
    }
}
    


    这里写图片描述 
    




    NamedParameterJdbcTemplate
    


    在JdbcTemplate中，我们只能使用？占位符来声明sql语句参数，使用索引来绑定参数，如果我们uyao新增一个占位符，可能会导致很多问题。这种编程模式被认为是弱稳定的。  
    


    NamedParameterJdbcTemplate模板类支持命名参数绑定的功能。  
    
SqlParameterSource接口用来提供参数 ，有两个实现类
    


     
     
    • BeanPropertySqlParameterSource：该类将JavaBean对象封装成参数，以便通过javaBean属性名和SQL语句中命名参数匹配的方式绑定参数。  
    • MapSqlParameterSource：该实现类内部通过一个Map存储参数。 
    






    //我们创建一个Dao类
public class StudentDao { 
    //提供NamedParameterJdbcTemplate，以便注入
    private NamedParameterJdbcTemplate template; 

    public void setTemplate(NamedParameterJdbcTemplate template) {
        this.template = template;
    }

    public void addStudent(User user){
        //使用命名参数，格式是:javaBean属性名 
        String sql="insert into user(username,password) values(:username,:password)"; 
        //提供参数
        SqlParameterSource sps=new BeanPropertySqlParameterSource(user);
        template.update(sql, sps);
    }
}

    




    <!--配置文件-->
<?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:aop="http://www.springframework.org/schema/aop"
    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.xsd
        http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop.xsd">

<context:property-placeholder location="jdbc.properties"/>
<bean id="datasource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
    <property name="driverClass" value="${driverClass}"></property>
    <property name="jdbcUrl" value="${jdbcUrl}"></property>
    <property name="user" value="${user}"></property>
    <property name="password" value="${password}"></property>
</bean> 

<bean id="template" class="org.springframework.jdbc.core.namedparam.NamedParameterJdbcTemplate">
    <constructor-arg ref="datasource"></constructor-arg>
</bean>
<bean id="studentdao" class="com.spring.jdbc.StudentDao">
    <property name="template" ref="template"></property>
</bean>
</beans>     
    




    //我们测试一下 
public class TestJdbc {

    @Test
    public void test() throws Exception{
        ApplicationContext ac=new ClassPathXmlApplicationContext("bean.xml");
        StudentDao studentdao=(StudentDao) ac.getBean("studentdao"); 
        User user=new User();
        user.setUsername("天蓬元帅");
        user.setPassword("123456");
        studentdao.addStudent(user);
    }

}
    


    这里写图片描述
    


    Spring在org.springframework.jdbc.object包中提供了若干个类，试图以更面向对象过的方式访问数据库，但从操作难易度和使用效果上看，我们看不到它的优势，基本算是很鸡肋的功能。Spring的Jdbc只要能用上述的一些基本操作即可，毕竟有许多专业的orm框架，例如Hibernate和Mybatis等。 
    




    Spring的事务操作
    


    实际开发中，Spring的事务管理基本上是被使用最多的功能，Spring的提供了灵活方便的事务管理功能。 
    


    事务的基础知识和可能遇到的数据并发问题还有数据隔离级别等知识在我的印象中已经写了两三次，可以从以前的博文中进行学习，这里就不再进行叙述。 
    




    JDBC对事务的支持
    




    //下面是传统的JDBC事务操作的代码 

    Connection conn;
    try{
        conn=DriverManager.getConnection(); 
        //开启事务
        conn.setAutoCommit(false);
        ....
        ....
        //提交事务
        conn.commit();
    }catch(Exception e){
        //回滚事务
        conn.rollback();
    }finally{
        ....
    }
    


    我们讲一个以前没讲过的小知识点，从JDBC3.0以后，引入了一个保存点特性，Savepoint接口允许将事务分割成多个阶段，用户可以指定回滚到事务特定的保存点。而以前的版本中，只要回滚就只能回滚到开始事务的点，这个保存点特性可以解决很多实际问题，在发生特定问题时，回滚到指定的保存点，我们来演示一下。 
    




        Connection conn;
    Savepoint s;
    try{
        conn=DriverManager.getConnection(); 
        //开启事务
        conn.setAutoCommit(false);
        执行A操作;
        执行B操作;
        //设置保存点
        s=conn.setSavepoint("savapoint");
        执行C操作
        执行D操作
        //提交事务
        conn.commit();
    }catch(Exception e){
        //判断是在AB操作时发生异常还是CD操作时发生异常
        if(s!=null){ 
            //回滚到保存点，并提交保存点之前的事务
            conn.rollback(s);
            conn.commit();
        }else{ 
            conn.rollback();
        }
    }finally{
        ....
    }
    




    Spring事务管理介绍
    


    Spring为事务管理提供了一致的编程模板，不管选择Spring JDBC、Hibernate、Mybatis，Spring都让我们可以用统一的编程模板进行事务管理。 
    


    Spring为我们提供了事务模板类，通过事务模板类就可以通过编程方式实现事务管理，而无需关注资源获取、释放、异常处理等操作。
    


    Spring事务管理的亮点在于声明式事务管理，Spring允许通过声明方式，在IoC配置中指定事务的边界和事务属性，Spring自动在指定的事务边界上应用事务属性。 
    


    Spring事务管理主要包括三个接口 
    




     
     
    • PlatformTransactionManager：  事务管理器。Spring使用事务管理器来管理事务的提交回滚等。
    • TransactionDefinition：事务属性。用来描述事务的隔离级别、超时时间、是否为只读事务等事务属性。我们配置事务属性，Spring会将事务封装到该对象实例。 
    • TransactionStatus：事务状态。用来记录事务的具体运行状态。例如事务是否有保存点，事务是否结束等。 
    






    PlatformTransactionManager详解
    


    PlatformTransactionManager定义了三个接口方法 
    




     
     
    • TransactionStatus getTransaction(TransactionDefinition  definition):该方法通过事务详情属性获得一个事务，并用TransactionStatus描述这个事务的状态  
    • commit(TransactionStatus  status):根据事务的状态提交事务，如果事务状态已经被标识为rollback-only，该方法执行回滚事务的操作   
    • rollback(TransactionStatus  status):根据状态回滚事务，commit()方法抛出异常时，该方法会被隐式调用
    




    Spring为不同的持久化框架提供了PlatformTransactionManager接口的实现类。 
    


    这里写图片描述
    




    TransactionStatus详解
    


    **TransactionStatus代表一个事务的具体运行状态。事务管理器通过该接口获取事务的运行期的状态信息。 
    
该接口继承SavepointManager接口**。 
    


    SavepointManager接口拥有以下的方法
    




     
     
    • Object  createSavepoint():创建一个保存点对象。 
    • void  rollbackToSavepoint(Object savepoint):回滚到指定的保存点  
    • void  releaseSavepoint(Object  savepoint):释放一个保存点。如果事务提交，所有保存点会自动释放。 
    




    TransactionStatus扩展了SavepointManager并提供了以下的方法 
    




     
     
    • boolean   hasSavepoint():判断当前的事务是否有保存点。  
    • boolean  isNewTransaction():判断当前的事务是否是一个新的事务。  
    • boolean  isCompleted():判断当前事务是否已经结束：已经提交或者回滚 
    • boolean isRollbackOnly():判断当前事务是否已经被标识为rollback-only  
    • void    setRollbackOnly():将当前事务设置为rollback-only,通过该标识通知事务管理器只能进行事务回滚。 
    






    TransactionDefinition详解
    


    TransactionDefinition定义了Spring的事务属性。
    




     
     
    • 事务隔离：事务隔离级别。在TransactionDefinition接口中定义了4个隔离级别。 分别是ISOLATION_READ_UNCOMMITTED，ISOLATION_READ_COMMITTED，ISOLATION_REPEATABLE_READ，ISOLATION_SERIALIZABLE。
    • 事务传播：后面详解。 
    • 事务超时：超时时间，事务运行超过指定时间时，事务将会回滚。 
    • 只读状态。只读状态，不能修改任何数据。
    




    TransactionDefinition接口中定义的方法
    




     
     
    • int getPropagationBehavior(); 获得传播行为 
    • int getIsolationLevel();  获得隔离级别  
    • int getTimeout();  获得超时时间  
    • boolean isReadOnly();  是否是只读状态  
    • String getName();  获取事务详情名称 
    




    事务传播行为 
    


    当我们进行开发时，事务一般都是设置在Service层，如果我们调用基于Spring的service方法时，它将运行于Spring管理的事务环境中，如果该Service方法中中除了调用Dao层的方法，在内部还调用了其他的Service方法来共同完成一个完整的业务操作，事务传播行为就是控制当前的事务如何传播到被调用的其他Service方法中。   
    


    Spring在TransactionDefinition接口中规定了七种类型的事务传播行为。
    


    这里写图片描述 
    




    Spring的编程式的事务管理
    


    实际应用中，很少需要通过编程来进行事务管理。Spring为编程式事务管理提供了模板类TransactionTemplate，TransactionTemplate是线程安全的，因此我们可以在业务类中共享TransactionTemplate进行事务管理。
    


    TracsactionTemplate有两个主要的方法 
    




     
     
    • void  setTransactionManager(PlatformTransactionManager  transactionManager):设置事务管理器  
    • Object  execute(TransactionCallback  action):在TransactionCallback回调接口中定义需要以事务方式组织的数据访问逻辑。简单的说需要以事务方式处理的代码放在这里面。
    • TransactionCallback接口中只有一个方法 ：Object  doInTransaction(TransactionStatus status).如果操作不会返回任何结果，可以使用TransactionCallback的子接口TransactionCallbackWithoutResult. 
    




    我们来演示一个银行转账的例子。
    


    //先创建数据库及要操作的数据表
CREATE DATABASE bank;
USE bank;
CREATE TABLE account(
    id  INT PRIMARY KEY AUTO_INCREMENT,
    username VARCHAR(50),
    money INT 
);

INSERT INTO account(username,money) VALUES('张三',1000);
INSERT INTO account(username,money) VALUES('李四',1000); 
    




    //创建Dao层，Dao层应该有两个方法，一个是给收款人加钱，一个给付款人减钱 
public class BankDao extends JdbcDaoSupport{ 
    //给收款人加钱的方法
    public void addMoney(String payee,Integer money){
        String sql="update account set money=money+? where username=?";
        this.getJdbcTemplate().update(sql, money,payee);
    }
    //给付款人减钱的方法
    public void reduceMoney(String payer,Integer money){
        String sql="update account set money=money-? where username=?";
        this.getJdbcTemplate().update(sql, money,payer);
    }

}

    




    //在Service层使用编程式事务进行转账操作 
public class BankService {
    private BankDao dao; 
    private TransactionTemplate template;
    public void setDao(BankDao dao) {
        this.dao = dao;
    } 
    public void setTemplate(TransactionTemplate template) {
        this.template = template;
    }

    //转账方法
    public void transfer(String payee,String payer,Integer money){  
        //因为没有返回结果，将转账的具体逻辑放在TransactionCallbackWithoutResult接口中
        template.execute(new TransactionCallbackWithoutResult() {
            protected void doInTransactionWithoutResult(TransactionStatus status) {
                dao.addMoney(payee, money);
                dao.reduceMoney(payer, money);  
            }
        });
    }
}
    




    <!--编写配置文件-->
<?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:aop="http://www.springframework.org/schema/aop"
    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.xsd
        http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop.xsd">
<!--加载数据库配置文件-->
<context:property-placeholder location="jdbc.properties"/> 
<!--设置连接池配置-->
<bean id="datasource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
    <property name="driverClass" value="${driverClass}"></property>
    <property name="jdbcUrl" value="${jdbcUrl}"></property>
    <property name="user" value="${user}"></property>
    <property name="password" value="${password}"></property>
</bean>  
<!--实例TransactionTemplate模板类，需要一个事务管理器-->
<bean id="template" class="org.springframework.transaction.support.TransactionTemplate">
    <property name="transactionManager" ref="transactionManager"></property>
</bean> 
<!--实例事务管理器，需要一个数据源-->
<bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
    <property name="dataSource" ref="datasource"></property>
</bean> 
<!--实例bankDao，需要数据源-->
<bean id="bankDao" class="com.spring.transa.BankDao">
    <property name="dataSource" ref="datasource"></property>
</bean>
<!--实例bankService，需要注入两个参数-->
<bean id="bankService" class="com.spring.transa.BankService">
    <property name="template" ref="template"></property>
    <property name="dao" ref="bankDao"></property>
</bean>
</beans>   
    




    //测试一下 
public class TestDemo {
    @Test
    public void test(){
        ApplicationContext ac=new ClassPathXmlApplicationContext("applicationContext.xml");
        BankService service=(BankService) ac.getBean("bankService");
        service.transfer("张三", "李四", 200);
    }
}

    


    这里写图片描述
    


    使用XML配置声明式事务
    


    大多数Spring用户选择声明式事务管理的功能，这种方式对代码的侵入性最小，让事务管理的代码完全从业务代码中移除，非常符合非侵入式轻量级容器的概念。Spring的声明式事务管理是通过AOP实现的，通过配置信息，Spring负责将事务管理增强逻辑动态织入到业务方法中。  
    


    使用原始的TransactionProxyFactoryBean 
    
Spring早期版本中，用户必须通过TransactionProxyFactoryBean代理类对需要进行事务管理的业务类进行代理，在Spring3.0以后，这种方式已经不被推荐，但是我们可以了解一下，有助于我们理解Spring声明式事务的内部工作原理。 、
    


    //我们还使用上面的转账例子
public class BankService {
    private BankDao dao; 

    public void setDao(BankDao dao) {
        this.dao = dao;
    } 

    public void transfer(String payee,String payer,Integer money){ 
                dao.addMoney(payee, money);
                //我们故意让抛出一个异常
                int i=1/0;
                dao.reduceMoney(payer, money);  
            }
    }

    


    <!--使用TransactionProxyFactoryBean配置-->
<?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:aop="http://www.springframework.org/schema/aop"
    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.xsd
        http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop.xsd">

<!--加载数据库配置文件-->
<context:property-placeholder location="jdbc.properties"/>
<bean id="datasource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
    <property name="driverClass" value="${driverClass}"></property>
    <property name="jdbcUrl" value="${jdbcUrl}"></property>
    <property name="user" value="${user}"></property>
    <property name="password" value="${password}"></property>
</bean> 

<!--配置事务管理器-->
<bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
    <property name="dataSource" ref="datasource"></property>
</bean>  
<!--配置Dao-->
<bean id="bankDao" class="com.spring.transa.BankDao">
    <property name="dataSource" ref="datasource"></property>
</bean>
<!--配置Service-->
<bean id="bankService" class="com.spring.transa.BankService">
    <property name="dao" ref="bankDao"></property>
</bean>  

<!--配置代理类-->
<bean id="proxyBankService" class="org.springframework.transaction.interceptor.TransactionProxyFactoryBean"> 
    <!--目标类-->
    <property name="target" ref="bankService"></property> 
    <!--事务管理器-->
    <property name="transactionManager" ref="transactionManager"></property>
    <!--事务属性，通过键值对的方式配置事务属性信息-->
    <property name="transactionAttributes">
        <props>
        <!--key为要进行事务管理的方法名，可以用*匹配所有方法-->
        <!--Value为属性值，格式为PROPAGATION(传播行为),ISOLATION(隔离级别 可选),readOnly(是否只读  可选),-Exceptions(发生这些异常回滚事务 可选),+Exceptions(发生这些异常照样提交事务 可选)-->
            <prop key="transfer">PROPAGATION_REQUIRED,+Exception</prop>
        </props>
    </property>
</bean>
</beans>   
    


    //进行测试 
public class TestDemo {
    @Test
    public void test(){
        ApplicationContext ac=new ClassPathXmlApplicationContext("applicationContext.xml");
        BankService service=(BankService) ac.getBean("proxyBankService");
        service.transfer("张三", "李四", 200);
    }
}

    


    这里写图片描述 
    


    我们可以看到，虽然出现了异常，但还是提交了事务。这就是我们设置的+Exception的作用
    


    基于tx/aop命名空间的配置
    


    使用TransactionProxyFactoryBean代理工厂类为业务类添加事务支持，有一些很明显的缺点，例如需要对每一个需要事务支持的业务类进行单独配置等。这一切的缺点是因为低版本Spring中没有引入强大的AOP切面表达式造成的，Spring引入AspectJ后，这一切自然就迎刃而解。 
    


    Spring在XML配置中，提供了tx命名空间，以明确的结构方式定义事务相关信息，配置aop提供的切面定义，事务配置得到了大大的简化。这也是开发中最常用的事务管理的方法 
    


    //我们还使用前面的银行转账的例子，都不需要改变 
//注意的是配置文件需要引入tx和aop命名空间
<?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:aop="http://www.springframework.org/schema/aop"
    xmlns:tx="http://www.springframework.org/schema/tx"         //引入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.xsd
        http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop.xsd

        //指定tx xsd文件位置
         http://www.springframework.org/schema/tx       http://www.springframework.org/schema/tx/spring-tx.xsd">

<context:property-placeholder location="jdbc.properties"/>
<bean id="datasource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
    <property name="driverClass" value="${driverClass}"></property>
    <property name="jdbcUrl" value="${jdbcUrl}"></property>
    <property name="user" value="${user}"></property>
    <property name="password" value="${password}"></property>
</bean> 

<!--定义事务管理器-->
<bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
    <property name="dataSource" ref="datasource"></property>
</bean> 
<!--定义Dao-->
<bean id="bankDao" class="com.spring.transa.BankDao">
    <property name="dataSource" ref="datasource"></property>
</bean>
<!--定义Service-->
<bean id="bankService" class="com.spring.transa.BankService">
    <property name="dao" ref="bankDao"></property>
</bean> 

<!--定义事务增强，需要指定id和事务管理器-->
<tx:advice id="txadvice" transaction-manager="transactionManager"> 
    <!--配置事务属性-->
    <tx:attributes>
        <tx:method name="transfer" propagation="REQUIRED" isolation="DEFAULT"/>
    </tx:attributes>
</tx:advice> 
<!--定义aop切面，使用AspectJ表达式定义切点-->
<aop:config>
    <aop:advisor pointcut="execution(* com.spring.transa.BankService.*(..))"  advice-ref="txadvice"/>
</aop:config>
</beans>    
    




    //我们测试一下 
public class TestDemo {
    @Test
    public void test(){
        ApplicationContext ac=new ClassPathXmlApplicationContext("applicationContext.xml");
        BankService service=(BankService) ac.getBean("bankService");
        service.transfer("张三", "李四", 200);
    }
}

    


    这里写图片描述
    


    使用注解配置声明式事务
    


    除了基于XML的事务配置之外，Spring还提供了基于注解的事务配置，使用@Transactional对需要使用注解的类或方法进行标注，在容器中配置基于注解的事务增强驱动，即可启用基于注解的声明式事务。 
    




    //对整个类使用注解，也可以对单独的方法使用注解 
//一般来说，我们只需要使用默认的事务属性即可，如果需要，直接使用以下格式
//@Transactional(propagation=Propagation.REQUIRED,isolation=Isolation.DEFAULT)
@Transactional
public class BankService {
    private BankDao dao; 

    public void setDao(BankDao dao) {
        this.dao = dao;
    } 

    public void transfer(String payee,String payer,Integer money){ 
                dao.addMoney(payee, money);
                int i=1/0;
                dao.reduceMoney(payer, money);  
            }
    }

    


    <?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:aop="http://www.springframework.org/schema/aop"
    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.xsd
        http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop.xsd
         http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx.xsd">

<context:property-placeholder location="jdbc.properties"/>
<bean id="datasource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
    <property name="driverClass" value="${driverClass}"></property>
    <property name="jdbcUrl" value="${jdbcUrl}"></property>
    <property name="user" value="${user}"></property>
    <property name="password" value="${password}"></property>
</bean> 

<bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
    <property name="dataSource" ref="datasource"></property>
</bean> 
<bean id="bankDao" class="com.spring.transa.BankDao">
    <property name="dataSource" ref="datasource"></property>
</bean>
<bean id="bankService" class="com.spring.transa.BankService">
    <property name="dao" ref="bankDao"></property>
</bean> 

<!--注解驱动，对添加@Transactional注解的Bean织入事务管理，peoxy-target-class属性如果为true，使用CGLib-->
<tx:annotation-driven transaction-manager="transactionManager"/>
</beans>
Zduomi
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
深入浅出学spring
05-21
《深入浅出学Spring》这一教学视频为Spring框架的学习提供了详尽且易懂的指导，尤其适合初学者。Spring框架是Java平台上的一个开源框架，它提供了一种全面的基础架构支持，让Java开发者能够开发出更为简洁、高效的...
Spring核心技术详解
梓鸿
02-19 2629
一、Sring简介 Spring是一个分层的Java SE/EE应用一站式的轻量级开源框架。Spring核心是IOC和AOP。Spring主要优点包括： 方便解耦，简化开发，通过Spring提供的IoC容器，我们可以将对象之间的依赖关系交由Spring进行控制，避免硬编码造成的程序耦合度高。 AOP编程的支持，通过Spring提供的AOP功能，方便进行面向切面编程。 声明式事务的支...
深入浅出Spring
liangyixin19800304的专栏
09-30 1851
深入浅出Spring（一）Spring概述        现在很多的企业级项目中基本上都会用到了Spring框架，那么为什么会出现Spring，Spring是什么？这次的博文我主要为大家简单介绍一下Spring。 Java EE优缺点        我们都知道在2003年Spring兴起之前，企业普遍使用J2EE技术来开发企业级应用，为什么用J2EE呢？主要原因有以下几个
【Java】深入浅出Spring
ronin的博客
06-15 863
Java Spring Framework笔记 1.Spring概述 1.1 什么是Spring Spring是一个开源框架，Spring是于2003 年兴起的一个轻量级的Java 开发框架，由Rod Johnson 在其著作Expert One-On-One J2EE Development and Design中阐述的部分理念和原型衍生而来。它是为了解决企业应用开发的复杂性而创建的。框架的主要优势之一就是其分层架构，分层架构允许使用者选择使用哪一个组件，同时为 J2EE 应用程序开发提供集成的框架。Sp
Spring的核心技术
weixin_44362089的博客
10-01 786
国庆也要做个合格的舔狗，
十道Spring选择题及解析。
bhegi_seg的博客
08-28 5456
解析：ApplicationContext是BeanFactory的子接口，ApplicationContext对象里面包含了BeanFactory的所有功能，并提供了一些扩展，比如更容易同SpringAOP特性整合，资源文件的处理，Spring为ApplicationContext提供的3种实现分别为：ClassPathXmlApplicationContext，FileSystemXmlApplicationContext和XmlWebApplicationContext。（AOP的好处，可背）...
深入浅出MyBatis技术原理与实战
06-05
《深入浅出MyBatis技术原理与实战》这本书旨在帮助读者全面理解MyBatis这一流行的Java持久层框架，深入解析其工作原理，并提供实战指导。MyBatis是一个轻量级的ORM（对象关系映射）框架，它允许开发者将SQL语句与...
深入浅出Mybatis技术原理与实战-高清pdf
01-26
《深入浅出Mybatis技术原理与实战》这本书旨在帮助读者全面理解MyBatis的内部工作机制，并通过实例演练提升实际开发技能。 首先，我们要了解MyBatis的核心概念。MyBatis是一个基于Java的持久层框架，它简化了数据库...
Spring深入浅出教程
06-22
本教程旨在帮助开发者深入理解Spring的核心概念和技术，从而更好地应用在实际项目中。 1. **依赖注入（Dependency Injection，DI）**：Spring的核心特性之一，允许开发者将对象之间的依赖关系解耦，使得组件之间...
Spring核心技术
恍惚窈冥
07-12 1245
Ch1. Spring概述Spring为企业应用的开发提供了一个轻量级的解决方案，包括基于依赖注入的核心机制，基于AOP的声明式事务管理，与多种持久层技术的整合，以及优秀的Web MVC框架等。Spring支持对POJO（Plain Object Java Object，指最传统的Java对象，和任何模式都无关）的管理。    Spring的作者是Rod Johnson。Spring独
java Jdbc编程入门
jasnet_u的博客
07-13 225
JDBC是什么？JDBC（Java DataBase Connectivity,java数据库连接）是一种用于执行SQL语句的Java API，可以为多种关系数据库提供统一访问，它由一组用Java语言编写的类和接口组成。JDBC提供了一种基准，据此可以构建更高级的工具和接口，使数据库开发人员能够编写数据库应用程序。示例代码如下：DBUtil.javapackage com.tingcream.sp...
Spring 深入浅出核心技术
lhw_csd的博客
08-03 566
Spring Spring简介 &lt;span style="color:#000000"&gt;&lt;code&gt;Spring是一个分层的Java SE/EE应用一站式的轻量级开源框架。Spring核心是IOC和AOP。 &lt;/code&gt;&lt;/span&gt; Spring优点 &lt;span style="color:#000000"&gt;&am
Spring核心技术详解(六)
面向搜素引擎编程
08-29 158
Spring事务管理机制详解
Spring框架系列(12) - Spring AOP实现原理详解之JDK代理实现
pdai的博客
07-04 171
JDK动态代理是有JDK提供的工具类Proxy实现的，动态代理类是在运行时生成指定接口的代理类，每个代理实例（实现需要代理的接口）都有一个关联的调用处理程序对象，此对象实现了InvocationHandler，最终的业务逻辑是在InvocationHandler实现类的invoke方法上。jdk代理不需要任何依赖。 定义实体 User 被代理的类和接口 接口如下 实现类如下： JDK代理类 代理类如下： 使用代理 启动类中指定代理目标并执行。 简单测试 我们启动上述类main 函数，执行的结果如下： JDK
深入浅出Spring 框架，原来以前白学了
a58125584s的博客
05-10 258
1. 为啥要用 Spring 张三是一个编程小白，他每次在 service 层写代码都要自己 new 一堆 Dao 接口的实现类。 public class ProjectServiceImpl implements ProjectService { UserDao userDao = new UserDaoImpl(); ProjectSectionDao projectSessionDao = new ProjectSessionDaoImpl(); ProjectDao
Spring 20年：缔造Java领域神话，近90% Java程序员形影不离
最新发布
图灵教育
03-24 696
题图 | Image by Freepik摘要：在编程世界，代码耦合性高、复杂性大的问题一直折磨着所有开发人员。为了解决这个问题，程序员前仆后继开发出了各种框架。但是没有一个特别能打、且让大部分程序员拍手称快的框架诞生。直到有一位年轻但经验丰富的 Java 程序员 Rod Johnson 出现，他和团队开发的一种框架，触动了无数程序员，这就是 Spring。2004 年的今天，首个稳定版 Spri...
Spring框架介绍 深入浅出 从小白到全面学习spring框架
weixin_49978788的博客
07-21 774
在学习Java后端开发中，spring框架是我们必须要掌握的重点知识。
《Spring深入浅出教程：理论知识、主要特性、常用技术与基本实例详解》
根据提供的内容，我们将对Spring深入浅出教程进行总结。 Spring是一款流行的Java开发框架，通过降低组件之间的耦合度，实现软件各层之间的解耦。它的核心特性包括依赖注入和控制反转，即通过外部容器动态地将依赖...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值