Spring笔记(3)：JdbcTemplate、事务管理、Spring5

已于 2022-03-30 22:26:56 修改
阅读量1.4k 收藏 2
点赞数 1
分类专栏： Spring5/Reactive/Flux 文章标签： java
于 2021-12-16 00:33:06 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/mingyuli/article/details/121964942
版权

目录

1、JdbcTemplate

1.1、方法：

1.2、举例：

2、事务管理

2.1、注解实现声明式事务管理：

（2）xml实现声明式事务管理：

3、Spring5新特性

3.1. 自带了日志封装

3.2. @Nullable注解

3.3. 支持函数式风格编程

3.4. 支持整合JUnit5

1、JdbcTemplate

  • Spring对JDBC进行封装，使用JdbcTemplate方便对数据库的操作。
    • 引入依赖
    • 在spring配置文件配置数据库连接池
    • 配置jdbcTemplate对象，注入DataSource
    • 创建service类，创建dao类，在dao注入jdbcTemplate对象

1.1、方法：

（1）增删改操作：

int update(String sql, Object... args);

（2）查询：返回某个值

T queryForObject(String sql,Class<T> requiredType);

（3）查询：返回某个对象

T queryForObject(String sql,RowMapper<T> rowMapper,Object ... args);

（4）查询：返回集合

List<T> query(String sql,RowMapper<T> rowMapper,Object... args);

（5）批量增删改：

int[] batchUpdate(String sql,List<Object[]> batchArgs);

1.2、举例：

  • 引入相关jar包
 <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-webmvc</artifactId>
            <version>5.1.8.RELEASE</version>
        </dependency>
  • 配置数据库连接池；配置JdbcTemplate对象
<context:component-scan base-package="com.oymn"></context:component-scan>

<!--配置数据库连接池 -->
<bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource" destroy-method="close">
    <property name="url" value="jdbc:mysql://localhost:3306/book" />
    <property name="username" value="root" />
    <property name="password" value="000000" />
    <property name="driverClassName" value="com.mysql.jdbc.Driver" />
</bean>

<!--创建JdbcTemplate对象-->
<bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">
    <!--注入数据库连接池-->
    <property name="dataSource" ref="dataSource"></property>
</bean>
  • 创建Service类和Dao类，在Dao类中注入JdbcTemplate对象
public interface BookDao {

    public void add(Book book);  //添加图书

    public void update(Book book);  //修改图书

    public void delete(int id);  //删除图书

    public int queryCount();   //查询数量

    public Book queryBookById(int id);  //查询某本书

    public List<Book> queryBooks();   //查询所有书

    public void batchAddBook(List<Object[]> books);  //批量添加图书

    public void batchUpdateBook(List<Object[]> books);  //批量修改图书

    public void batchDeleteBook(List<Object[]> args);  //批量删除图书
}


@Repository
public class BookDaoImpl implements BookDao {

    @Autowired
    private JdbcTemplate jdbcTemplate;

    @Override
    public void add(Book book) {
        String sql = "insert into t_book set name=?,price=?";
        Object[] args = {book.getBookName(),book.getBookPrice()};
        int update = jdbcTemplate.update(sql, args);
        System.out.println(update);
    }

    @Override
    public void update(Book book) {
        String sql = "update t_book set name=?,price=? where id=?";
        Object[] args = {book.getBookName(),book.getBookPrice(),book.getBookId()};
        int update = jdbcTemplate.update(sql, args);
        System.out.println(update);
    }

    @Override
    public void delete(int id) {
        String sql = "delete from t_book where id=?";
        int update = jdbcTemplate.update(sql, id);
        System.out.println(update);
    }

    @Override
    public int queryCount() {
        String sql = "select count(*) from t_book";
        Integer count = jdbcTemplate.queryForObject(sql, Integer.class);
        return count;
    }

    @Override
    public Book queryBookById(int id) {
        String sql = "select id bookId,name bookName,price bookPrice from t_book where id=?";
        Book book = jdbcTemplate.queryForObject(sql, new BeanPropertyRowMapper<Book>(Book.class), id);
        return book;
    }

    @Override
    public List<Book> queryBooks() {
        String sql = "select id bookId,name bookName,price bookPrice from t_book";
        List<Book> bookList = jdbcTemplate.query(sql, new BeanPropertyRowMapper<Book>(Book.class));
        return bookList;
    }

    @Override
    public void batchAddBook(List<Object[]> books) {
        String sql = "insert into t_book set id=?,name=?,price=?";
        int[] ints = jdbcTemplate.batchUpdate(sql, books);
        System.out.println(ints);
    }

    @Override
    public void batchUpdateBook(List<Object[]> books) {
        String sql = "update t_book set name=?,price=? where id=?";
        int[] ints = jdbcTemplate.batchUpdate(sql, books);
        System.out.println(ints);
    }

    @Override
    public void batchDeleteBook(List<Object[]> args) {
        String sql = "delete from t_book where id=?";
        int[] ints = jdbcTemplate.batchUpdate(sql, args);
        System.out.println(ints);
    }
}


@Service
public class BookService {
    @Autowired
    private BookDao bookDao = new BookDaoImpl();
    //添加图书
    public void add(Book book){
        bookDao.add(book);
    }
    //修改图书
    public void update(Book book){
        bookDao.update(book);
    }
    //删除图书
    public void delete(Integer id){
        bookDao.delete(id);
    }
    //查询数量
    public int queryCount(){
        return bookDao.queryCount();
    }
    //查询图书
    public Book queryBookById(Integer id){
        return bookDao.queryBookById(id);
    }
    //查询所有图书
    public List<Book> queryBooks(){
        return bookDao.queryBooks();
    }
    //批量添加图书
    public void batchAddBook(List<Object[]> books){
        bookDao.batchAddBook(books);
    }
    //批量修改图书
    public void batchUpdateBook(List<Object[]> books){
        bookDao.batchUpdateBook(books);
    }
    //批量删除图书
    public void batchDeleteBook(List<Object[]> args){
        bookDao.batchDeleteBook(args);
    }
}

2、事务管理

 事务是数据库操作最基本单位，要么都成功，要么都失败。

  • 典型场景：转账
  • 事务四个特性ACID：
    • 原子性
    • 一致性
    • 隔离性
    • 持久性
  • Spring事务管理有两种方式：
    • 编程式事务管理
    • 声明式事务管理
    • 一般使用声明式事务管理，底层使用AOP原理。
  • 声明式事务管理有两种方式：基于xml配置方式 和 基于注解方式，一般使用注解方式。
  • Spring事务管理提供了一个接口，叫事务管理器，该接口针对不同的框架提供不同的实现类。

        对于使用JdbcTemplate进行数据库交互，则使用DataSourceTransactionManager实现类，如果整合Hibernate框架则使用HibernateTransactionManager实现类，具体情况具体使用。

案例分析：

public interface UserDao {

    //多钱
    public void addMoney();
    //少钱
    public void reduceMoney();
}
@Repository
public class UserDaoImpl implements UserDao {

    @Autowired
    private JdbcTemplate jdbcTemplate;


    @Override
    public void addMoney() {
        String sql = "update user_db set money = money + ? where username = ?";
        jdbcTemplate.update(sql,100,"mary");
    }

    @Override
    public void reduceMoney() {
        String sql = "update user_db set money = money - ? where username = ?";
        jdbcTemplate.update(sql,100,"lucy");
    }
}
@Service
public class UserService {

    //注入dao
    @Autowired
    private UserDao userDao;

    //转账
    public void accountMoney(){
        //lucy少100
        userDao.reduceMoney();
        //mary多100
        userDao.addMoney();

    }
}

<?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:aop="http://www.springframework.org/schema/aop"
       xmlns:context="http://www.springframework.org/schema/context"
       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:component-scan base-package="springtransaction"></context:component-scan>

   <!--配置数据库连接池 -->
   <bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource" destroy-method="close">
      <property name="url" value="jdbc:mysql://localhost:3306/mybatis" />
      <property name="username" value="root" />
      <property name="password" value="123456" />
      <property name="driverClassName" value="com.mysql.jdbc.Driver" />
   </bean>

   <!--创建JdbcTemplate对象-->
   <bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">
      <!--注入数据库连接池-->
      <property name="dataSource" ref="dataSource"></property>
   </bean>



</beans>
public class TestBook {

    @Test
    public void testAccount(){
        ApplicationContext context = new ClassPathXmlApplicationContext("bean4.xml");
        UserService userService = context.getBean("userService", UserService.class);
        userService.accountMoney();

    }
}

上述代码，如果正常执行没有问题，但是如果代码执行过程中，出现异常会有问题。

问题例如：

@Service
public class UserService {

    //注入dao
    @Autowired
    private UserDao userDao;

    //转账
    public void accountMoney(){
        //lucy少100
        userDao.reduceMoney();

        //模拟异常
        int i = 100/0;

        //mary多100
        userDao.addMoney();

    }
}

如何解决：

使用事务，事务过程：

@Service
public class UserService {

    //注入dao
    @Autowired
    private UserDao userDao;

    //转账
    public void accountMoney(){
        try {
            //1、开启事务

            //2、处理逻辑
            //lucy少100
            userDao.reduceMoney();

            //模拟异常
            int i = 100/0;

            //mary多100
            userDao.addMoney();

            //3、没有异常，提交事务
        } catch (Exception e) {
            //4、出现异常，事务回滚
        }

    }
}

1、事务添加到三层结果里Service层（业务逻辑层）

2、在Spring进行事务管理操作

  • 有两种方式：编程式事务管理和声明式事务管理（使用）

3、编程式事务管理：上面代码的1234步骤

4、声明式事务管理有两种方式：基于xml配置方式 和 基于注解方式，一般使用注解方式。

5、在Spring进行声明式事务管理，底层使用AOP原理

6、Spring事务管理API

  • 提供了一个接口，代表事务管理器，这个接口针对不同的框架提供不同的实现类。

 对于使用JdbcTemplate进行数据库交互，则使用DataSourceTransactionManager实现类，如果整合Hibernate框架则使用HibernateTransactionManager实现类，具体情况具体使用。

2.1、注解实现声明式事务管理：

  • 在spring配置文件，配置事务管理器
  • 在spring配置文件，开启事务注解
  • 在service类上面或者service类的方法上面添加事务注解@Transactional
<?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:aop="http://www.springframework.org/schema/aop"
       xmlns:tx="http://www.springframework.org/schema/tx"
       xmlns:context="http://www.springframework.org/schema/context"
       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">
<!-- 数据库连接池 -->
<bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource"
      destroy-method="close">
    <property name="url" value="jdbc:mysql://localhost:3306/book" />
    <property name="username" value="root" />
    <property name="password" value="000000" />
    <property name="driverClassName" value="com.mysql.jdbc.Driver" />
</bean>

<!--创建JdbcTemplate对象-->
<bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">
    <!--注入数据库连接池-->
    <property name="dataSource" ref="dataSource"></property>
</bean>

<!--创建事务管理器-->
<bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
    <property name="dataSource" ref="dataSource"/>
</bean>

<!--开启事务注解-->
<tx:annotation-driven transaction-manager="transactionManager"></tx:annotation-driven>

在service类上面或者service类的方法上面添加事务注解@Transactional

  • 如果把@Transactional添加在类上面，这个类里面所有方法都添加事务。
  • 如果只是添加在方法上面，则只为这个方法添加事务。

声明式事务管理的参数配置：

在service中配置@Transactional注解，在这个注解里可以配置事务参数：

  1. propagation：事务传播行为，总共有7种

事务方法：对数据库表数据进行变化的操作，比如更新，增加，删除。查询不是。

多事务方法直接进行调用，这个过程中事务是如何进行管理的。例如：

  •  一个事务方法调用另一个无事务方法
  •  一个无事务方法调用另一个事务方法
  •  一个事务方法调用另一个事务方法

required：如果add方法本身有事务，调用update方法之后，update使用当前add方法里面事务，如果add方法本身没有事务，调用update方法之后，创建新事物

required_new：使用add方法调用update方法，如果add 无论是否有事务，都创建新的事务。

@Service
@Transactional(propagation = Propagation.REQUIRED)
public class UserService {

}

  1. isolation：事务隔离级别

    不考虑隔离型会有三个读问题：脏读，不可重复读，虚读（幻读）。

    设置隔离级别，解决读问题：

@Service
@Transactional(propagation = Propagation.REQUIRED,isolation = Isolation.REPEATABLE_READ)
public class UserService {

}

    3. timeout：超时时间

  • 事务需要在一定时间内进行提交，超过时间后回滚。
  • 默认值是-1，表示不超时，设置时间以秒为单位。
@Service
@Transactional(timeout = -1,propagation = Propagation.REQUIRED,isolation = Isolation.REPEATABLE_READ)
public class UserService {

}

    4. readOnly：是否只读

  • 默认值为false，表示可以查询，也可以增删改。
  • 设置为true，只能查询。
@Service
@Transactional(readOnly = true,timeout = -1,propagation = Propagation.REQUIRED,isolation = Isolation.REPEATABLE_READ)
public class UserService {

}

    5. rollbackFor：回滚，设置出现哪些异常进行事务回滚。
    6. noRollbackFor：不回滚，设置出现哪些异常不进行事务回滚。

@Service
@Transactional(propagation = Propagation.REQUIRED,isolation = Isolation.READ_COMMITTED)
public class AccountService {

}

完全注解实现声明式事务管理：

创建配置类，使用配置类代替xml配置文件

@Configuration  //配置类
@ComponentScan(basePackages = "com.oymn.spring5")  //开启组件扫描
@EnableTransactionManagement  //开启事务
public class Config {

    //创建数据库连接池
    @Bean
    public DruidDataSource getDruidDataSource(){
        DruidDataSource druidDataSource = new DruidDataSource();
        druidDataSource.setDriverClassName("com.mysql.jdbc.Driver");
        druidDataSource.setUrl("jdbc:mysql://localhost:3306/mybatis");
        druidDataSource.setUsername("root");
        druidDataSource.setPassword("123456");
        return druidDataSource;
    }
    //创建JdbcTemplate对象
    @Bean
    public JdbcTemplate getJdbcTemplate(DataSource dataSource){
        //到ioc容器中根据类型找到dataSource        
        JdbcTemplate jdbcTemplate = new JdbcTemplate();
        jdbcTemplate.setDataSource(dataSource);
        return jdbcTemplate;
    }
    //创建事务管理器
    @Bean
    public DataSourceTransactionManager getDataSourceTransactionManager(DataSource dataSource){
        DataSourceTransactionManager transactionManager = new DataSourceTransactionManager();
        transactionManager.setDataSource(dataSource);
        return transactionManager;
    }
}

@Service
public class AccountService {

    @Autowired
    private AccountDao accountDao;

    @Transactional
    public void accountMoney(){
        accountDao.add();
        //int i=1/0;   //用来模拟转账失败
        accountDao.reduce();
    }
}

（2）xml实现声明式事务管理：

  • spring配置文件中配置事务管理器
  • spring配置文件中配置通知
  • spring配置文件中配置切入点和切面
<context:component-scan base-package="com.oymn"></context:component-scan>

<!-- 数据库连接池 -->
<bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource"
      destroy-method="close">
    <property name="url" value="jdbc:mysql://localhost:3306/book" />
    <property name="username" value="root" />
    <property name="password" value="000000" />
    <property name="driverClassName" value="com.mysql.jdbc.Driver" />
</bean>

<!--创建JdbcTemplate对象-->
<bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">
    <!--注入数据库连接池-->
    <property name="dataSource" ref="dataSource"></property>
</bean>

<!--创建事务管理器-->
<bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
    <property name="dataSource" ref="dataSource"/>
</bean>

<!--配置事务通知-->
<tx:advice id="txadvice">
    <!--配置事务参数-->
    <tx:attributes>
        <tx:method name="accountMoney" propagation="REQUIRED" />
    </tx:attributes>
</tx:advice>

<!--配置切入点和切面-->
<aop:config>
    <!--配置切入点-->
    <aop:pointcut id="pt" expression="execution(* com.oymn.spring5.Service.*.*(..))"/>
    <!--配置切面-->
    <aop:advisor advice-ref="txadvice" pointcut-ref="pt"/>
</aop:config>

3、Spring5新特性

  • 整个Spring5框架的代码基于Java8，运行时兼容JDK9，许多不建议使用的类和方法在代码库中删除。
  • Spring5.0框架 自带了通用的日志框架

3.1. 自带了日志封装

  • Spring5移除了Log4jConfigListener，官方建议使用Log4j2

Spring5整合Log4j2：

第一步：引入jar包

<!--${log4j.version}这是版本信息，可以根据自己的需要填写，我用的是最新的2.11.2-->
		<dependency>
            <groupId>org.apache.logging.log4j</groupId>
            <artifactId>log4j-api</artifactId>
            <version>${log4j.version}</version>
        </dependency>

        <dependency>
            <groupId>org.apache.logging.log4j</groupId>
            <artifactId>log4j-core</artifactId>
            <version>${log4j.version}</version>
        </dependency>

        <dependency>
            <groupId>org.apache.logging.log4j</groupId>
            <artifactId>log4j-web</artifactId>
            <version>${log4j.version}</version>
        </dependency>

第二步：创建log4j2.xml配置文件

<?xml version="1.0" encoding="UTF-8"?>
<!--日志级别以及优先级排序: OFF > FATAL > ERROR > WARN > INFO > DEBUG > TRACE > ALL -->
<!--Configuration后面的status用于设置log4j2自身内部的信息输出，可以不设置，当设置成trace时，可以看到log4j2内部各种详细输出-->
<configuration status="INFO">
    <!--先定义所有的appender-->
    <appenders>
        <!--输出日志信息到控制台-->
        <console name="Console" target="SYSTEM_OUT">
            <!--控制日志输出的格式-->
            <PatternLayout pattern="%d{yyyy-MM-dd HH:mm:ss.SSS} [%t] %-5level %logger{36} - %msg%n"/>
        </console>
    </appenders>
    <!--然后定义logger，只有定义了logger并引入的appender，appender才会生效-->
    <!--root：用于指定项目的根日志，如果没有单独指定Logger，则会使用root作为默认的日志输出-->
    <loggers>
        <root level="info">
            <appender-ref ref="Console"/>
        </root>
    </loggers>
</configuration>

public class UserLog {

    private static final Logger log = LoggerFactory.getLogger(UserLog.class);

    public static void main(String[] args) {
        log.info("hello log4j2");
        log.warn("hello log4j2");
    }
}

02:33:32.740 [main] INFO springtransaction.UserLog - hello log4j2
02:33:32.747 [main] WARN springtransaction.UserLog - hello log4j2

3.2. @Nullable注解

  • @Nullable注解可以用在方法上，属性上，参数上，表示方法返回值可以为空，属性可以为空，参数可以为空。

@Nullable     //表示方法返回值可以为空
public int getId();

@Nullable     //表示参数可以为空
public void setId(@Nullable int Id);

@Nullable     //表示属性可以为空
public int id;

3.3. 支持函数式风格编程

这是因为java8新增了lamda表达式

@Test
public void test() {
    //1 创建 GenericApplicationContext 对象
        GenericApplicationContext context = new GenericApplicationContext();
        //2 调用 context 的方法对象注册
        context.refresh();
        context.registerBean("user1", User.class,() -> new User());
        //3 获取在 spring 注册的对象
        User user = (User)context.getBean("user1");
        System.out.println(user);//aopanno.User@3d0f8e03

        //3 获取在 spring 注册的对象
        //使用全路径
        context.registerBean( User.class,() -> new User());
        User user1 = (User)context.getBean("com.atguigu.spring5.test.User");
        System.out.println(user1);//aopanno.User@3d0f8e03
    
}

3.4. 支持整合JUnit5

（1）整合JUnit4：

第一步：引入jar包

<dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-test</artifactId>
            <version>5.2.8.RELEASE</version>
        </dependency>
<dependency>
    <groupId>junit</groupId>
    <artifactId>junit</artifactId>
    <version>4.12</version>
    <scope>test</scope>
</dependency>

第二步：创建测试类，使用注解方式完成

@RunWith(SpringJUnit4ClassRunner.class) //单元测试框架版本
@ContextConfiguration("classpath:bean4.xml") //加载配置文件
public class JUnitTest {

    @Autowired
    public User user;

    @Test
    public void test(){
        System.out.println(user);
    }
}

其中

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration("classpath:bean1.xml")
相当于
ApplicationContext context=new AnnotationConfigApplicationContext(Config.class);

bean4.xml：

<context:component-scan base-package="com.oymn"></context:component-scan>

通过使用@ContextConfiguration注解，测试方法中就不用每次都通过context来获取对象了，比较方便。

ApplicationContext context = new ClassPathXmlApplicationContext("bean2.xml");
BookService bookService = context.getBean("bookService",BookService.class);

（2）整合JUnit5：

<dependency>
     <groupId>org.junit.jupiter</groupId>
      <artifactId>junit-jupiter</artifactId>
      <version>5.6.2</version>
      <scope>test</scope>
</dependency>

image-20210807212940977


 

CodingALife
关注
专栏目录
Spring5 学习总结—JdbcTemplate，事务管理
m0_52901132的博客
04-10 2260
JdbcTemplate（概念和准备） 1.什么是JdbcTemplate 1.1 Spring框架对JDBC进行封装，使用 JdbcTemplate 方便实现对数据库操作 2.准备工作 2.1 导入依赖 <dependency> <groupId>org.springframework</groupId> <artifactId>spring-jdbc</art...
【Spring实战（第5版）阅读笔记】：整合JdbcTemplate
小沈杰的小世界
02-15 711
准备数据库 创建数据库：study CREATE DATABASE `study` 创建表：hobby CREATE TABLE `hobby` ( `aid` int NOT NULL AUTO_INCREMENT COMMENT '自增主键', `content` varchar(32) NOT NULL COMMENT '爱好内容', PRIMARY KEY (`aid`) ) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=ut
Spring JdbcTemplate 与 事务管理
小飞侠的博客
07-20 350
Spring JdbcTemplate 事务管理 Spring的JDBC框架能够承担资源管理和异常处理的工作,从而简化我们的JDBC代码, 让我们只需编写从数据库读写数据所必需的代码。Spring把数据访问的样板代码隐藏到模板类之下, 结合Spring的事务管理,可以大大简化我们的代码. Spring提供了3个模板类： JdbcTemplate：Spring里最基本的JDBC...
SpringJdbcTemplate添加代码事务支持
xwnxwn的专栏
02-12 979
1. [代码][Java]代码      ? 1 2 3 4 5 6 7 public interface JdbcTemplate extends JdbcOperations {     public abstract void beginTranstaion();
Spring(六)JdbcTemplate，事务控制
weixin_50204197的博客
03-03 2502
JdbcTemplate，spring事务，Transaction
jdbcTemplate添加事务管理器
qq_43621676的博客
12-01 163
中添加事务管理器，你需要使用 Spring 框架的事务管理功能。结合使用，实现在数据库操作中的事务管理。通过以上步骤，你可以将事务管理器与。注：保存一下个人遇到的问题。
Spring笔记之整合JdbcTemplate.doc
最新发布
03-23
### Spring与JdbcTemplate整合详解 #### 一、JdbcTemplate简介及使用 ...通过以上步骤，可以实现Spring框架与JdbcTemplate的有效整合，并进一步结合声明式事务管理和Struts2框架，实现更为复杂的应用场景。
SSH笔记-Spring JdbcTemplate
06-17
4. **事务管理**：Spring的JdbcTemplate也整合了事务管理功能，通过`JdbcTemplate.execute()`方法的回调函数，可以在一个操作中包裹多个数据库操作，确保原子性和一致性。如果发生异常，事务会自动回滚，否则在所有...
Spring笔记：声明式事务管理与ProxyTransactionManagementConfiguration详解
本文档主要介绍了Spring框架中的ProxyTransactionManagementConfiguration在声明式事务管理中的作用。首先，它在Spring容器中注册了事务增强器，这些增强器基于事务注解（如@Transactional）的信息进行配置，由...
Spring框架学习笔记06：Spring JdbcTemplate入门
aqaerw的博客
05-12 187
## 一、JdbcTemplate概述 （一）JdbcTemplate作用 Spring对数据库的操作在JDBC上面做了深层次的封装，使用Spring的注入功能，可以把DataSource注册到JdbcTemplate之中，从而方便地实现对数据库的访问操作。 （二）JdbcTemplate操作数据库常用方法 execute方法：用于执行任何SQL语句，一般用于执行DDL语句 update方法：用于执行新增、修改、删除等语句 batchUpdate方法：用于执行更新批处理相关语句 query方
spring实现jdbctemplate添加事务支持示例
10-26
主要介绍了spring实现jdbctemplate添加事务支持示例，重写JdbcTemplate增加beginTranstaion,commit,rollback方法,需要的朋友可以参考下
配制Spring事务和JdbcTemplate使用
10-08
配制Spring事务和JdbcTemplate使用 配制Spring事务和JdbcTemplate使用
jdbctemplate batchupdate 的事务管理
热门推荐
huijianpang的专栏
03-31 1万+
良好的心态是不断前进的 -  献给不再年轻的自己 数据库：sqlserver 2014 事务管理方式：编程式事务管理 数据库访问：spring jdbctemplate 目的：测试batchupdate 的事务控制 1. 不加显式的事务管理      测试结果：batchupdate 中的每一条记录都会自动的commit，如果有异常，则只有异常的数据执行失败，其他数据不
Spring之JdbcTemplate 的事务控制 （编程式）基于XML和注解
运算符重载之String
08-09 496
声明式事务控制1. 编程式事务控制相关对象1.1 PlatformTransactionManager1.2 TransactionDefinition2 编程式事务控制2.1 事务隔离级别2.2 事务传播行为2.3 TransactionStatus2.4 知识要点3 基于 XML 的声明式事务控制3.1 什么是声明式事务控制3.2 声明式事务控制的实现3.3 切点方法的事务参数的配置3.4 知识要点4 基于注解的声明式事务控制4.1 使用注解配置声明式事务控制4.2 注解配置声明式事务控制解析4.3 知
Java：66-Spring的JDBCTemplate与声明式事务
qq_59609098的博客
04-23 1312
核心方法： 举个栗子： 查询数据库所有账户信息到Account实体中： Spring整合JdbcTemplate ： 需求 基于Spring的xml配置实现账户的CRUD案例 步骤分析： 创建java项目，导入坐标 ： 编写Account实体类： 编写AccountDao接口和实现类： 编写AccountService接口和实现类： 编写spring核心配置文件 ： 编写测试代码： 实现转账案例： 步骤分析： 创建java项目，导入坐标 ： 编写Account实体类： 编写Ac
spring中JDBC编程式事务
yeson6的专栏
12-07 3451
在spring采用纯JDBC进行数据库操作：applicationContext.xml<beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://www.
Spring JdbcTemplate&声明式事务
无区新手的博客
07-10 201
JdbcTemplate基本使用 JdbcTemplate基本使用-概述(了解) JdbcTemplate是spring框架中提供的一个对象，是对原始繁琐的Jdbc API对象的简单封装。spring框架为我们提供了很多的操作模板类。例如：操作关系型数据的JdbcTemplate和HibernateTemplate，操作nosql数据库的RedisTemplate，操作消息队列的JmsTemplate等等。 JdbcTemplate基本使用-开发步骤(理解) 导入s..
Spring6 JdbcTemplate和事务
Lifelong learning
06-17 4332
数据库事务( transaction)是访问并可能操作各种数据项的一个数据库操作序列，这些操作要么全部执行,要么全部不执行，是一个不可分割的工作单位。事务由事务开始与事务结束之间执行的全部数据库操作组成。
Spring中JDBCTemplate的事务实现
Alexwym的博客
05-22 4130
一、事务的定义及特性 （一）、事务的定义 1、事务是一个最小的不可再分割的执行单元，它由批量的DML语句构成，这些语句要么全部执行，要不全都不执行。 2、通常一个事务对应一个完整的业务。比如典型的转账业务，从账户A中转账1000元给账户B。操作过程分为两步，第一步从账户A中扣去1000元，第二步往账户B中加上1000元。显然这两个操作要么都得做，要么都不做。如果只做其中一个操作，数据库的数据...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值