Spring5(第四天）

最新推荐文章于 2023-08-01 08:56:10 发布
最新推荐文章于 2023-08-01 08:56:10 发布
阅读量134 收藏
点赞数
分类专栏： spring
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_44788518/article/details/109387243
版权
JdbcTemplate(概念和准备)
1、什么是 JdbcTemplate

（1）为了简化持久化操作，Spring在JDBC API之上提供了JdbcTemplate组件。Spring 框架对 JDBC 进行封装，使用 JdbcTemplate 方便实现对数据库操作

2、准备工作

（1）引入相关 jar 包
在这里插入图片描述
（2）在 spring 配置文件配置数据库连接池

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

    <bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource">
        <property name="url"
                  value="jdbc:mysql:///user_db?useSSL=false&amp;serverTimezone=UTC&amp;characterEncoding=utf8"/>
        <property name="username" value="root"/>
        <property name="password" value="123456"/>
        <property name="driverClassName" value="com.mysql.jdbc.Driver"/>


    </bean>
    <bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">
        <property name="dataSource" ref="dataSource"/>

    </bean>
    
    <context:component-scan base-package="jdbcTemplate操作"></context:component-scan>
    
</beans>

entity包下的类：
book:
与数据库中的表相映射

package jdbcTemplate操作.entity;

public class Book {
    private String userId;
    private String userName;
    private String userStatus;

    public Book() {
    }

    public Book(String userId, String userName, String useStatus) {
        this.userId = userId;
        this.userName = userName;
        this.userStatus = useStatus;
    }

    public void setUserId(String userId) {
        this.userId = userId;
    }
    public void setUserName(String userName) {
        this.userName = userName;
    }
    public void setUserStatus(String useStatus) {
        this.userStatus = useStatus;
    }
    public String getUserId() {
        return userId;
    }
    public String getUserName() {
        return userName;
    }
    public String getUserStatus() {
        return userStatus;
    }
    @Override
    public String toString() {
        return "Book{" +
                "userId='" + userId + '\'' +
                ", userName='" + userName + '\'' +
                ", userStatus='" + userStatus + '\'' +
                '}';
    }
}

在这里插入图片描述

Dao包下的类：
BookDao

package jdbcTemplate操作.Dao;

import jdbcTemplate操作.entity.Book;

import java.util.List;

public interface BookDao {
    void add(Book book);

    void delete(String id);

    void update(Book book);

    int selectCount();

    Book findBookInfo(String id);

    List<Book> findAll();

    void bathAdd(List<Object[]> bathArgs);


}

BookDaoImpl

package jdbcTemplate操作.Dao;

import jdbcTemplate操作.entity.Book;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.jdbc.core.BeanPropertyRowMapper;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.stereotype.Component;

import java.util.Arrays;
import java.util.List;
@Component
public class BookDaoImpl implements BookDao{
    @Autowired
    private JdbcTemplate jdbcTemplate;
    //添加一条数据
    @Override
    public void add(Book book) {
      String sql="insert into t_book values(?,?,?)";
      Object[] args={book.getUserId(),book.getUserName(),book.getUserStatus()};
      int update=jdbcTemplate.update(sql,args);
        System.out.println(update);

    }
   //删除一条数据
    @Override
    public void delete(String id) {
        String sql="delete from t_book where user_id=?";
        int update=jdbcTemplate.update(sql,id);
        System.out.println(update);
    }
   //更新一条数据
    @Override
    public void update(Book book) {
        String sql="update t_book set user_id=?,user_name=?,user_status=? where user_id=?";
        Object[] objects={book.getUserId(),book.getUserName(),book.getUserStatus(),book.getUserId()};
        int update=jdbcTemplate.update(sql, objects);

        System.out.println(update);
    }
    //获取表中的数据个数
    @Override
    public int selectCount() {

        String sql="select COUNT(*) from t_book";
        int res=jdbcTemplate.queryForObject(sql,Integer.class);
        return res;
    }
   //找到指定id在表中的数据
    @Override
    public Book findBookInfo(String id) {
        String sql="select user_id as userId,user_name as userName,user_status as userStatus from t_book where user_id=?";
        Book book=jdbcTemplate.queryForObject(sql,new BeanPropertyRowMapper<Book>(Book.class),id);
        return book;
    }
   //获得表中所有数据
    @Override
    public List<Book> findAll() {
        String sql="select * from t_book";
        List<Book> books=jdbcTemplate.query(sql,new BeanPropertyRowMapper<Book>(Book.class));

        return books;
    }
   //批量添加数据
    @Override
    public void bathAdd(List<Object[]> bathArgs) {
      String sql="insert into t_book values(?,?,?)";
      int[] bathUpdate=jdbcTemplate.batchUpdate(sql,bathArgs);
        System.out.println(Arrays.toString(bathUpdate));

    }
}

service包下的类：
userDaoService

package com.atguigu.spring5.service;

import com.atguigu.spring5.dao.BookDao;
import com.atguigu.spring5.entity.Book;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.util.List;

@Service
public class BookService {

    //注入dao
    @Autowired
    private BookDao bookDao;

   //添加的方法
    public void addBook(Book book){
        bookDao.add(book);
    }
   //修改的方法
    public void updateBook(Book book){
        bookDao.update(book);
    }
    //删除的方法
    public void deleteBook(String id){
        bookDao.delete(id);
    }
    //查询表记录数
    public int findCount(){
       return bookDao.selectCount();
    }
    //查询返回对象
    public Book findBookInfo(String id){
        return bookDao.findBookInfo(id);
    }
    //返回查询集合
    public List<Book> findAll(String id){
        return bookDao.findAll(id);
    }
   //批量添加
    public  void bathAdd(List<Object[]> batchArgs ){
    bookDao.bathAdd(batchArgs);
    }
}

service包下的类：
BookService

package jdbcTemplate操作.service;
import jdbcTemplate操作.Dao.BookDao;
import jdbcTemplate操作.entity.Book;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
import java.util.List;

@Component
public class BookService {
    @Autowired
    public BookDao bookDao;
    public void addBook(Book book) {
        bookDao.add(book);
    }
    public void updateBook(Book book) {
        bookDao.update(book);
    }
    public void deleteBook(String id) {
        bookDao.delete(id);
    }
    public int findCount() {
     return    bookDao.selectCount();
    }
    public Book findBookInfo(String id) {
        return bookDao.findBookInfo(id);
    }
    public List<Book> findAll() {
        return bookDao.findAll();
    }
    public void bathAdd(List<Object[]> bathArgs) {
        bookDao.bathAdd(bathArgs);
    }
}

test类：

package jdbcTemplate操作.test;
import jdbcTemplate操作.entity.Book;
import jdbcTemplate操作.service.BookService;
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import java.util.ArrayList;
import java.util.List;

public class test1 {
    @Test
    public void test1(){
        ApplicationContext context=new ClassPathXmlApplicationContext("jdbcTemplate操作/beans/bean1.xml");
        BookService bookService = context.getBean("bookService", BookService.class);
        Book book=new Book();
        book.setUserId("10");
        book.setUserName("tom");
        book.setUserStatus("true");
        bookService.addBook(book);
        bookService.deleteBook("10");
        book.setUserId("5");
        bookService.updateBook(book);
        System.out.println(bookService.findCount());
        System.out.println(bookService.findBookInfo("4"));
        System.out.println(bookService.findAll());
        List<Object []> list=new ArrayList<>();
        Object[] object1={"6","bob","fine"};
        Object[] object2={"7","mary","no"};
        list.add(object1);
        list.add(object2);
        bookService.bathAdd(list);
    }
}

1.insert,delete,update操作都是通过jdbcTemplate.update(sql,args)实现的。
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
2.查询表中的数据量：jdbcTemplate.queryObject(sql,Integer.class)
在这里插入图片描述3.查询表中单个数据时
jdbcTemplate.queryObject(sql,Book.class)
在这里插入图片描述
4.查询多个数据时：
在这里插入图片描述
在这里插入图片描述
5.插入多个数据：
在这里插入图片描述
在这里插入图片描述
6.删除多个数据
在这里插入图片描述

事务操作（事务概念）
1、什么事务

（1）事务是数据库操作最基本单元，逻辑上一组操作，要么都成功，如果有一个失败所有操作都失败
（2）典型场景：银行转账

  • lucy 转账 100 元 给 mary
  • lucy 少 100，mary 多 100
2、事务四个特性（ACID）

(1).原子性：一个事务不可再分割，要么都执行要么都不执行
(2).一致性：一个事务执行会使数据从一个一致状态切换到另外一个一致状态
(3).隔离性：一个事务的执行不受其他事务的干扰
(4).持久性：一个事务一旦提交，则会永久的改变数据库的数据.

3.事务操作（搭建事务操作环境）

在这里插入图片描述
1、创建数据库表，添加记录
在这里插入图片描述
2、创建 service，搭建 dao，完成对象创建和注入关系
（1）service 注入 dao，在 dao 注入 JdbcTemplate，在 JdbcTemplate 注入 DataSource
3、在 dao 创建两个方法：多钱和少钱的方法，在 service 创建方法（转账的方法）
下面问题如何解决呢？
使用事务进行解决

dao包下的类：
userDao:

package 事务操作.dao;

public interface UserDao {
    void addMoney(int money,String id);
    void subMoney(int money,String id);
}

UserDaoImpl:

package 事务操作.dao;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.stereotype.Component;
import 事务操作.entity.User;
import javax.annotation.Resource;

@Component(value = "userDaoImpl")
public class UserDaoImpl implements UserDao{
    @Autowired
     private JdbcTemplate jdbcTemplate;
    @Override
    public void addMoney(int money, String id) {
        String sql="update t_account set money=money+? where id=?";
        int update=jdbcTemplate.update(sql,money,id);
        System.out.println(update);
    }
    @Override
    public void subMoney(int money, String id) {
        String sql="update t_account set money=money-? where id=?";
        int update=jdbcTemplate.update(sql,money,id);
        System.out.println(update);
    }
}

service包下的类：
UserService:

package 事务操作.service;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
import 事务操作.dao.UserDao;
@Component(value = "userService")
public class UserService {
    @Autowired
    private UserDao userDao;

    public void accountMoney(){
        //第一步 开启事务

        //第二步 进行业务操作

        userDao.addMoney(100,"1");
        int a=1/0;//模拟异常
        userDao.subMoney(100,"2");
        //第三步 没有发生异常提交事务

        //第四步 出现异常，事务回滚
    }
}
事务操作（Spring 事务管理介绍）

1、事务添加到 JavaEE 三层结构里面 Service 层（业务逻辑层）
2、在 Spring 进行事务管理操作
（1）有两种方式：编程式事务管理和声明式事务管理（使用）
3、声明式事务管理
（1）基于注解方式（使用）
（2）基于 xml 配置文件方式
4、在 Spring 进行声明式事务管理，底层使用 AOP 原理
5、Spring 事务管理 API
（1）提供一个接口，代表事务管理器，这个接口针对不同的框架提供不同的实现类
在这里插入图片描述

事务操作（注解声明式事务管理）

1、在 spring 配置文件配置事务管理器

    <bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource">
        <property name="driverClassName" value="com.mysql.jdbc.Driver"/>
        <property name="username" value="root"/>
        <property name="password" value="123456"/>
        <property name="url"
                  value="jdbc:mysql:///user_db?useSSL=false&amp;serverTimezone=UTC&amp;characterEncoding=utf8"/>
    </bean>
    <bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
        <property name="dataSource" ref="dataSource"/>
    </bean>

2、在 spring 配置文件，开启事务注解
（1）在 spring 配置文件引入名称空间 tx
（2）开启事务注解

<?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:component-scan base-package="事务操作"></context:component-scan>
<!--    开启事务注解-->
    <tx:annotation-driven transaction-manager="transactionManager"></tx:annotation-driven>
    <bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">
        <property name="dataSource" ref="dataSource"/>
    </bean>

    <bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource">
        <property name="driverClassName" value="com.mysql.jdbc.Driver"/>
        <property name="username" value="root"/>
        <property name="password" value="123456"/>
        <property name="url"
                  value="jdbc:mysql:///user_db?useSSL=false&amp;serverTimezone=UTC&amp;characterEncoding=utf8"/>
    </bean>
<!--    配置事务管理器-->
    <bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
        <property name="dataSource" ref="dataSource"/>
    </bean>
</beans>

3、在 service 类上面（或者 service 类里面方法上面）添加事务注解
（1）@Transactional，这个注解添加到类上面，也可以添加方法上面
（2）如果把这个注解添加类上面，这个类里面所有的方法都添加事务
（3）如果把这个注解添加方法上面，为这个方法添加事务

事务操作（声明式事务管理参数配置）

1、在 service 类上面添加注解@Transactional，在这个注解里面可以配置事务相关参数
在这里插入图片描述
2.propagation:事务传播行为
3.isolation:事务隔离级别
4.timeout：超出时间
5.readOnly:是否可读
6.rollbackFor:回滚
7.noRollbackFor:不回滚

2、propagation：事务传播行为
（1）多事务方法直接进行调用，这个过程中事务 是如何进行管理的（有事务的方法调用没有事务的方法，没有事务的方法调用有事务的方法。有事务的方法调用有事务的方法。这就是传播行为。）
在这里插入图片描述
七种传播行为
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
3、ioslation：事务隔离级别
（1）事务有特性成为隔离性，多事务操作之间不会产生影响。不考虑隔离性产生很多问题
（2）有三个读问题：脏读、不可重复读、虚（幻）读
（3）脏读：一个未提交事务读取到另一个未提交事务的数据
（4）不可重复读：一个未提交事务读取到另一提交事务修改数据
（5）幻读：一个未提交事务读取到另一提交事务添加数据
（6）解决：通过设置事务隔离级别，解决读问题

隔离级别脏读不可重复读幻读
读未提交（Read uncommitted）×(未解决)××
读已提交（Read committed）√(解决)××
可重复读（Repeatable read）√√×
可串行化（Serializable）√√√

在这里插入图片描述

4、timeout：超时时间
（1）事务需要在一定时间内进行提交，如果不提交进行回滚
（2）默认值是 -1 ，设置时间以秒单位进行计算
5、readOnly：是否只读
（1）读：查询操作，写：添加修改删除操作
（2）readOnly 默认值 false，表示可以查询，可以添加修改删除操作
（3）设置 readOnly 值是 true，设置成 true 之后，只能查询
6、rollbackFor：回滚（rollbackFor=Eeception.class）
（1）设置出现哪些异常进行事务回滚
7、noRollbackFor：不回滚
（1）设置出现哪些异常不进行事务回滚

事务操作（XML 声明式事务管理）

1、在 spring 配置文件中进行配置
第一步 配置事务管理器
第二步 配置通知(通知：被增强的部分，这里是事务)
第三步 配置切入点和切面

<?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:component-scan base-package="事务操作"></context:component-scan>
    <bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource"></bean>
    <bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">
        <property name="dataSource" ref="dataSource"/>
    </bean>

<!--   1. 创建事务管理器-->
    <bean id="tansactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
<!--        注入数据源-->
        <property name="dataSource" ref="dataSource"></property>

    </bean>
<!--    2.配置通知-->

    <tx:advice id="txadvice">
<!--        配置事务参数-->
        <tx:attributes>
<!--            指定哪种规则的方法上面添加事务-->
            <tx:method name="accountMoney" propagation="REQUIRED" isolation="REPEATABLE_READ"/>
<!--            <tx:method name="account*"/> 表示以account开头的方法-->
        </tx:attributes>


    </tx:advice>
<!--配置切入点和切面-->
     <aop:config>
<!--         配置切入点-->
         <aop:pointcut id="pt" expression="execution(* 事务操作.service.UserService.*(..))"/>
<!--         配置切面-->
         <aop:advisor advice-ref="txadvice" pointcut-ref="pt"/>
     </aop:config>
    
    
</beans>
事务操作（完全注解声明式事务管理）

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

package 事务操作;




import com.alibaba.druid.pool.DruidDataSource;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.jdbc.datasource.DataSourceTransactionManager;
import org.springframework.transaction.annotation.EnableTransactionManagement;

import javax.sql.DataSource;

@Configuration//配置类
@ComponentScan(basePackages = "事务操作")//组件扫描
@EnableTransactionManagement//开启事务
public class ConfigClass {

    //创建数据库
    @Bean
    public DruidDataSource getDruidDataSource(){
        DruidDataSource dataSource=new DruidDataSource();
        dataSource.setDriverClassName("com.mysql.jdbc.Driver");
        dataSource.setUsername("root");
        dataSource.setPassword("123456");
        dataSource.setUrl("jdbc:mysql:///user_db?useSSL=false&amp;serverTimezone=UTC&amp;characterEncoding=utf8");
        return dataSource;

    }
    //创建jdbcTemplate对象
    public JdbcTemplate getJdbcTemplate(DataSource dataSource){
        //到ioc容器中根据类型找到dataSource
        JdbcTemplate jdbcTemplate=new JdbcTemplate();
        jdbcTemplate.setDataSource(dataSource);
        return jdbcTemplate;
    }

    //创建事务管理器
    @Bean
    public DataSourceTransactionManager getDataDataSourceTransactionManager(DataSource dataSource){
        DataSourceTransactionManager transactionManager=new DataSourceTransactionManager();
        transactionManager.setDataSource(dataSource);
        return transactionManager;
    }

}

前往Spring5和mybatis进行整合

扎克风暴
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
spring5第四天.pdf
05-25
1.Spring 中的 JdbcTemplate[会用] 2.Spring 中的事务控制 3. Spring5 的新特性[了解]
【宋红康 MySQL数据库 】【高级篇】【16】事务基础知识
a1k2l45k的博客
12-14 589
事务基础知识
spring mybatis 动态SQL的insert
最新发布
虾米大王的学习历程
08-01 719
插入数据库的记录中，不是每一个字段都有值，此时就可以使用if标签。在INSERT 动态插入中使用if标签。（1）条件：只有非空属性才插入。
写在前面【mysql高级】【java提高】
小心星的博客
07-25 295
导航【mysql高级】【java提高】
Spring总结
stone_bk的博客
06-11 209
Spring介绍 Spring 是一个开源框架，是一个分层的 JavaEE 一站式框架。 所谓一站式框架是指 Spring 有 JavaEE 开发的每一层解决方案。 WEB层：SpringMVC Service层：Spring的Bean管理，声明式事务 DAO层：Spring的JDBC模板，ORM模板 优点： IOC：方便解耦合 AOP：对程序进行扩展 轻量级框架 方便与其他框架整合 Spring使用 Spring开发包解压后的目录
11、声名式事务
qq_63486066的博客
10-20 110
①加入依赖②创建jdbc.properties③配置spring的配置文件
spring5第一天.pdf
02-25
介绍：spring框架的概述以及spring中基于XML的IOC配置。 主要内容： 1、spring的概述 spring是什么 spring的两大核心 spring的发展历程和优势 spring体系结构 2、程序的耦合及解耦 曾经案例中问题 ...
spring第四天.pdf
04-22
4. 掌握AOP核心概念（通知、切入点、切面、代理对象、目标对象、织入等） 5. 了解切入点表达式 6. 了解通知类型（五种） 7. 重点掌握aop底层的原理之动态代理机制的概述及差别 8. 重点掌握JDK代理技术之产生代理对象...
spring5新特性
01-27
前方：对于很多开发人员来说，目前大都还在使用spring4的时候，而spring5早已经发布。虽然你可能暂时还没有使用到spring5，但还是需要对其有个大概的了解。Spring5于2017年9月发布了通用版本(GA)，它标志着自2013年...
Spring JDBC 批量插入
白石的专栏
11-30 1638
在本文中，我们创建了一个简单的示例来展示我们如何从 Spring JDBC 对插入的批处理支持中获益。我们将常规插入与批处理插入进行了比较，获得了大约 80-90% 的性能提升。当然，在使用批处理功能的同时，我们还需要考虑我们的JDBC驱动的支持和效率。
Spring框架2016版黑马程序员第四天相关的资料
12-26
黑马程序员的Spring框架的第四天的资料，包含了资料，代码，截图和当前这堂课的笔记
Spring Boot + Jpa(Hibernate) 架构基本配置
热门推荐
JAVA_HIGHNESS的专栏
11-06 7万+
1、基于springboot-1.4.0.RELEASE版本测试 2、springBoot + Hibernate + Druid + Mysql + servlet(jsp) 不废话，直接上代码一、maven的pom文件<?xml version="1.0" encoding="UTF-8"?> <project xmlns="http://maven.apache.org/PO
两种使用Spring JdbcTemplate实现update或insert操作
我的世界我的梦
10-15 3万+
第一种方式，重载PreparedStatementCreator jdbcTemplate.update(new PreparedStatementCreator()...{    public PreparedStatement createPreparedStatement(Connection conn)...{        String sql="insert into us
springboot @Select @Insert @Update @Delete@Options
qq_20867981的博客
06-10 1万+
@RequestMapping("/select") @ResponseBody public void select() { System.out.println(userMapper.findByName("Michael").toString()); } @RequestMapping("/select2") @ResponseBody public void select...
SpringBoot + Mybatis 的 insert 通过注解传入多个参数
倪默遥
01-10 8068
直接上代码，希望对大家有帮助 @Insert("insert into a_manu_model(manu_code,model_code) values(#{manuCode},#{modelCode})") void addManuModel(@Param("manuCode")String manuCode, @Param("modelCode") String modelCode);
Spring JDBC 常用批量操作及插入操作
沉默的鲨鱼的专栏
07-30 730
Spring 常用批量操作有很多种方法，但是大多数人知道一种或者其中的几种，先总结一些spring JDBC常用的批量操作的方法及其效率； 使用JDBCTemplate 进行基本的批量操作 这种方法是网上大多数采用的方法， 但是在实际应用中我感觉不太方便，这个方法能不能做成一个通用的接口呢？一直没有仔细研究过     public class JdbcActorDa
Spring+JDBC组合开发 - 使用JdbcTemplate进行insert/update/delete/query操作
Larry的博客
07-07 2683
1. dao类   package com.jxhuang.transaction_xml.dao;   import java.util.List;   import javax.sql.DataSource;   import org.springframework.jdbc.core.JdbcTemplate;   import com.jxhuang.t
Spring事务理解和配置
Student108的博客
09-07 2364
文章目录1 Spring事务1.1 事务简介1.1.1 什么是事务1.1.2 事物的特性1.1.3 不考虑事物会引发的安全问题1.1.4 事务隔离级别1.2 事务的传播行为1.3 编程式事务(需要手动写代码,了解)1.3.1 配置平台事务管理器1.3.2 Spring提供了事务管理的模板类1.3.3 在业务层注入事务管理的模板1.3.4 编写事务管理的代码1.4 声明式事务(xml配置)1.4.1 配置事务管理器1.4.2 配置增强1.4.3 AOP的配置1.5 声明式事务(注解)1.5.1 配置事务管理器
spring 实战(第四版).pdf
06-22
《Spring实战》第四版是一本介绍Spring框架的经典教材，由Craig Walls编写。本书全面系统地讲解了Spring框架的核心概念、应用场景和各种功能的使用方法，涵盖了Spring的IoC、AOP、JDBC、Web、安全等方面的知识。 ...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

扎克风暴

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值