Spring框架（4）

最新推荐文章于 2023-09-08 10:46:26 发布
最新推荐文章于 2023-09-08 10:46:26 发布
阅读量91 收藏
点赞数
分类专栏： 框架 文章标签： spring
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_54823276/article/details/116239612
版权

1、Spring_JDBCTemplate的使用

JdbcTemplate概述

JdbcTemplate是spring框架中提供的一个对象，是对原始繁琐的Jdbc API对象的简单封装。spring框架为我们提供了很多的操作模板类。例如：操作关系型数据的JdbcTemplate和，操作nosql数据库的RedisTemplate，操作消息队列的JmsTemplate等等。
在这里插入图片描述
项目结构准备：
在这里插入图片描述

导入依赖

<packaging>jar</packaging>
    <dependencies>
        <!--spring核心容器包-->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>5.3.5</version>
        </dependency>
        <!--spring切面包-->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-aspects</artifactId>
            <version>5.3.5</version>
        </dependency>
        <!--aop联盟包-->
        <dependency>
            <groupId>aopalliance</groupId>
            <artifactId>aopalliance</artifactId>
            <version>1.0</version>
        </dependency>
        <!--德鲁伊连接池-->
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>druid</artifactId>
            <version>1.1.10</version>
        </dependency>
        <!--mysql驱动-->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>8.0.22</version>
        </dependency>
        <!--springJDBC包-->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-jdbc</artifactId>
            <version>5.3.5</version>
        </dependency>
        <!--spring事务控制包-->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-tx</artifactId>
            <version>5.3.5</version>
        </dependency>
        <!--spring orm 映射依赖-->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-orm</artifactId>
            <version>5.3.5</version>
        </dependency>
        <!--Apache Commons日志包-->
        <dependency>
            <groupId>commons-logging</groupId>
            <artifactId>commons-logging</artifactId>
            <version>1.2</version>
        </dependency>
        <!--Junit单元测试-->
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.13.1</version>
            <scope>test</scope>
        </dependency>
        <!--lombok -->
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <version>1.18.12</version>
            <scope>provided</scope>
        </dependency>
    </dependencies>

准备JDBC.properties

jdbc_username=root
jdbc_password=root
jdbc_driver=com.mysql.cj.jdbc.Driver
jdbc_url=jdbc:mysql://127.0.0.1:3306/mydb?useSSL=false&useUnicode=true&characterEncoding=UTF-8&serverTimezone=Asia/Shanghai&allowPublicKeyRetrieval=true

准备applicationcontext.xml

xmlns:context="http://www.springframework.org/schema/context"
xsi:schemaLocation="
http://www.springframework.org/schema/context
http://www.springframework.org/schema/context/spring-context.xsd

 <!--spring 注解扫描-->
    <context:component-scan base-package="com.wml"/>
    <!--读取jdbc配置文件-->
    <context:property-placeholder location="classpath:jdbc.properties"/>
    <!--配置德鲁伊连接池-->
    <bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource">
        <property name="username" value="${jdbc_username}"></property>
        <property name="password" value="${jdbc_password}"></property>
        <property name="url" value="${jdbc_url}"></property>
        <property name="driverClassName" value="${jdbc_driver}"></property>
    </bean>
    <!--配置JDBCTemplate对象,并向里面注入DataSource-->
    <bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">
        <!--通过set方法注入连接池-->
        <property name="dataSource" ref="dataSource"></property>
    </bean>

准备实体类

@AllArgsConstructor
@NoArgsConstructor
@Data
public class Emp implements Serializable {
    private Integer empno;
    private String ename;
    private String job;
    private Integer mgr;
    private Date hiredate;
    private Double sal;
    private Double comm;
    private Integer deptno;
}

准备Service层接口和实现类

public interface EmpService {
    /*查询方法*/
    int findEmpCount();
    Emp findByEmpno(int empno);
    List<Emp> findByDeptno(int deptno);
    /*增加*/
    int addEmp(Emp emp);
    int updateEmp(Emp emp);
    int deleteEmp(int empno);
 }

@Service
public class EmpServiceImpl implements EmpService {
    /*需要调用dao层来查询员工个数*/
    @Autowired
    private EmpDao empDao;

    @Override
    public int findEmpCount() {
        return empDao.findEmpCount();
    }

    @Override
    public Emp findByEmpno(int empno) {
        return empDao.findByEmpno(empno);
    }

    @Override
    public List<Emp> findByDeptno(int deptno) {
        return empDao.findByDeptno(deptno);
    }

    @Override
    public int addEmp(Emp emp) {
        return empDao.addEmp(emp);
    }
    @Override
    public int updateEmp(Emp emp) {
        return empDao.updateEmp(emp);
    }
    @Override
    public int deleteEmp(int empno) {
        return empDao.deleteEmp(empno);
    }
}

准备Dao层接口和实现类

public interface EmpDao {
    int findEmpCount();
    Emp findByEmpno(int empno);
    List<Emp> findByDeptno(int deptno);
    int addEmp(Emp emp);
    int updateEmp(Emp emp);
    int deleteEmp(int empno);
}

@Repository
public class EmpDaoImpl implements EmpDao {
    @Autowired
    private JdbcTemplate jdbcTemplate;

    @Override
    public int findEmpCount() {
        /*
         * 查询员工个数
         * jdbcTemplate.queryForObject三个参数
         * 第一个参数 SQL语句
         * 第二个参数 RowMapper接口的实现类对象,用于执行返回的结果用哪个类来进行封装 ,实现类为BeanPropertyRowMapper
         *
         * */
        String sql = "select count(1) from emp";
        /*实现功能*/
        Integer integer = jdbcTemplate.queryForObject(sql, Integer.class);
        /*queryForObject用Integer.class类来封装SQL语句*/
        return integer;
    }

    @Override
    public Emp findByEmpno(int empno) {
        /*
        * 查询单个员工对象
        * 第一个参数 SQL语句
        * 第二个参数 RowMapper接口的实现类对象,用于执行返回的结果用哪个类来进行封装 ,实现类为BeanPropertyRowMapper
        * 第三个参数 SQL语句中需要的参数 (可变参数)
        * */
        String sql = "select * from emp where empno=?";
        BeanPropertyRowMapper<Emp> rowMapper = new BeanPropertyRowMapper<Emp>(Emp.class);
        Emp o = jdbcTemplate.queryForObject(sql,rowMapper,empno);
        return o;
    }

    @Override
    public List<Emp> findByDeptno(int deptno) {
        /*
        *查询多个员工对象集合
        *query三个参数
        *第一个参数 SQL语句
        *第二个参数 RowMapper接口的实现类对象,用于执行返回的结果用哪个类来进行封装 ,实现类为BeanPropertyRowMapper
        *第三个参数 SQL语句中需要的参数 (可变参数)
        * */
        String sql = "select * from emp where deptno = ?";
        BeanPropertyRowMapper<Emp> rowMapper = new BeanPropertyRowMapper<Emp>(Emp.class);
        List<Emp> emps = jdbcTemplate.query(sql, rowMapper, deptno);
        return emps;
    }

    @Override
    public int addEmp(Emp emp) {
        /*
         * 增删改员工信息
         * 统统用update方法 两个参数
         * jdbcTemplate.update
         * 第一个参数 SQL语句
         * 第三个参数 SQL语句需要的参数 (可变参数)
         * */
        String sql ="insert into emp values(DEFAULT ,?,?,?,?,?,?,?)";
        Object[] args ={emp.getEname(),emp.getJob(),emp.getMgr(),emp.getHiredate(),emp.getSal(),emp.getComm(),emp.getDeptno()};
        return jdbcTemplate.update(sql,args);
    }
    @Override
    public int updateEmp(Emp emp) {
        String sql ="update emp set ename =? , job =?, mgr=? , hiredate =?, sal=?, comm=?, deptno =? where empno =?";
        Object[] args ={emp.getEname(),emp.getJob(),emp.getMgr(),emp.getHiredate(),emp.getSal(),emp.getComm(),emp.getDeptno(),emp.getEmpno()};
        return jdbcTemplate.update(sql,args);
    }
    @Override
    public int deleteEmp(int empno) {
        String sql ="delete  from emp where empno =?";
        return jdbcTemplate.update(sql, empno);
    }
}

测试代码

public class Test01 {
    @Test
    public void testEmpService(){
        ApplicationContext context = new ClassPathXmlApplicationContext("applicationcontext.xml");
        EmpService empService = context.getBean(EmpService.class);
        //context.getBean("EmpServiceImpl",EmpService.class);id和类型
        // 查询员工个数
        /*int empCount = empService.findEmpCount();
        System.out.println(empCount);*/
        // 根据员工编号查询员工对象
        /*Emp emp = empService.findByEmpno(7521);
        System.out.println(emp);*/
        /*根据部门编号查询多个员工对象集合*/
        /*List<Emp> emps = empService.findByDeptno(20);
        emps.forEach(System.out::println);*/

        /*增加员工信息*/
        /*int rows = empService.addEmp(new Emp(null, "TOM", "SALESMAN", 7521, new Date(), 2000.0, 100.0, 10));
        System.out.println(rows);*/
        /*根据员工编号修改员工信息*/
        /*int rows = empService.updateEmp(new Emp(7935, "JERRY", "MANAGER", 7839, new Date(), 3000.0, 0.0, 20));
        System.out.println(rows);*/
        /*根据员工编号删除员工信息*/
        int rows = empService.deleteEmp(7935);
        System.out.println(rows);
    }
}

2、Spring_JDBCTemplate批操作

一次连接,操作表格里的多条数据,就是批量操作
1 批量增加
2 批量修改
3 批量删除
项目结构、导入依赖、准备JDBC.properties、准备applicationcontext.xml
在1、Spring_JDBCTemplate的使用中

实体类

@AllArgsConstructor
@NoArgsConstructor
@Data
public class Dept implements Serializable {
        private Integer DEPTNO;
        private String DNAME;
        private String LOC;
}

准备Service层接口和实现类

public interface DeptService {
    /*批量增删改*/
    int[] deptBatchAdd(List<Dept> depts);
    int[] deptBatchUpdate(List<Dept> depts);
    int[] deptBatchDelete(List<Integer> deptnos);
}

@Service
public class DeptServiceImpl implements DeptService {
    /*需要调用dao层来增删改*/
    @Autowired
    private DeptDao deptDao;

    @Override
    public int[] deptBatchAdd(List<Dept> depts) {
        int[] ints = deptDao.deptBatchAdd(depts);
        return ints;
    }

    @Override
    public int[] deptBatchUpdate(List<Dept> depts) {

        return deptDao.deptBatchUpdate(depts);
    }

    @Override
    public int[] deptBatchDelete(List<Integer> deptnos) {
        return deptDao.deptBatchDelete(deptnos);
    }
}

准备Dao层接口和实现类

public interface DeptDao {
    int[] deptBatchAdd(List<Dept> depts);
    int[] deptBatchUpdate(List<Dept> depts);
    int[] deptBatchDelete(List<Integer> deptnos);
}

@Repository
public class DeptDaoImpl implements DeptDao {
    @Autowired
    private JdbcTemplate jdbcTemplate;

    @Override
    public int[] deptBatchAdd(List<Dept> depts) {
        String sql = "insert into dept values(DEFAULT,?,?)";
        List<Object[]> args = new LinkedList<Object[]>();
        for (Dept dept : depts) {
            Object[] arg = {dept.getDNAME(),dept.getLOC()};
            args.add(arg);
        }
        int[] ints = jdbcTemplate.batchUpdate(sql, args);
        return ints;
    }

    @Override
    public int[] deptBatchUpdate(List<Dept> depts) {
        String sql = "update dept set DNAME = ? , LOC = ? where deptno = ?";
        List<Object[]> args = new LinkedList<Object[]>();
        for (Dept dept : depts) {
            Object[] arg = {dept.getDNAME(),dept.getLOC(),dept.getDEPTNO()};
            args.add(arg);
        }
        return jdbcTemplate.batchUpdate(sql,args);
    }

    @Override
    public int[] deptBatchDelete(List<Integer> deptnos) {
        String sql = "delete from dept where deptno = ?";
        List<Object[]> args = new LinkedList<Object[]>();
        for (Integer deptno : deptnos) {
            Object[] arg = {deptno};
            args.add(arg);
        }
        return jdbcTemplate.batchUpdate(sql,args);
    }
}

测试代码

public class Test02 {
    @Test
    public void testdeptBatchAdd(){
        ApplicationContext context = new ClassPathXmlApplicationContext("applicationcontext.xml");
        DeptService deptService = context.getBean(DeptService.class);
        List<Dept> depts = new ArrayList<>();
        for (int i = 0; i <10 ; i++) {
            depts.add(new Dept(null,"name"+i,"loc"+i));
        }
        int[] ints = deptService.deptBatchAdd(depts);
        System.out.println(Arrays.toString(ints));
    }

    @Test
    public void testdeptBatchUpdate(){
        ApplicationContext context = new ClassPathXmlApplicationContext("applicationcontext.xml");
        DeptService deptService = context.getBean(DeptService.class);
        List<Dept> depts = new ArrayList<>();
        for (int i = 86; i <96 ; i++) {
            depts.add(new Dept(i,"newNAME","newLOC"));
        }
        int[] ints = deptService.deptBatchUpdate(depts);
        System.out.println(Arrays.toString(ints));
    }

    @Test
    public void testdeptBatchDelete(){
        ApplicationContext context = new ClassPathXmlApplicationContext("applicationcontext.xml");
        DeptService deptService = context.getBean(DeptService.class);
        List<Integer> deptnos = new ArrayList<>();
        for (int i = 86; i <96 ; i++) {
            deptnos.add(i);
        }
        int[] ints = deptService.deptBatchDelete(deptnos);
        System.out.println(Arrays.toString(ints));
    }
}
欣欣。
关注
专栏目录
spring&hibernate(01-简单构建)
Fengshunui的博客
03-13 329
pom.xml<dependency> <groupId>junit</groupId> <artifactId>junit</artifactId> </dependency> <dependency> <groupId>org.springframework</groupId> <artifactId>spring-core</artifactId> </depe
最新版本的Struts2+Spring4+Hibernate4框架整合
10-15
同时使用了Struts2、Spring4、Hibernate4、log4j、slf4j、junit4、ehcache等库或框架，搭建一个最基本的项目原型。 三、 三大框架最新版本下载：截止2014-10-01 Struts2.3.6：发布于2014-05-03，目前的最新版本。...
Spring JDBC模板类—org.springframework.jdbc.core.JdbcTemplate
07-26
NULL 博文链接：https://just-do-myself.iteye.com/blog/663368
jquery 页面滚动条回到顶部_js滚动条回到顶部的代码
weixin_39530149的博客
12-21 179
虽然平滑性处理的不好，但非常适合学习//怎么获取网页的高度 让页面一出来就滚动条在最底端function myScroll(){//前边是获取chrome等一般浏览器 如果获取不到就是ie了 就用ie的办法获取var x=document.body.scrollTop||document.documentElement.scrollTop;var timer=setInterval(functio...
spring中的jdbcTemplate
胡云峰的博客
10-21 399
spring中的jdbcTemplate
org.springframework.jdbc.core.JdbcTemplate
小默学习笔记
07-23 2442
在Idea中使用 JdbcTemplate 导入依赖： 就可以使用类：org.springframework.jdbc.core.JdbcTemplate <!-- https://mvnrepository.com/artifact/org.springframework/org.springframework.jdbc --> <dependency> <groupId>org.springframework</g
spring框架api中文版.zip(spring开发手册）
04-06
即Spring框架的概述 1。 介绍Spring框架 1.1。 依赖注入和控制反转 1.2。 模块 1.2.1。 核心容器 1.2.2。 数据访问/集成 1.2.3。 web 1.2.4。 AOP和仪表 1 2 5。 测试 1.3。 使用场景 1.3.1。 依赖关系管理和命名...
spring框架2016
08-26
最新spring框架2016视频教程，包含源码和笔记。小白入手实用教程。
Spring框架精讲
06-29
通过Spring的入门程序介绍了Spring的 IoC 和 DI 的概念，介绍了Spring的基本模块。详细介绍了对象创建的细节和依赖注入的几种方式；介绍了如何使用注解完成Spring的相关功能；介绍了如何借助于Spring搭建JUnit测试...
org.springframework.jdbc.core.JdbcTemplate 常用操作
Mrzhang__的专栏
11-18 9919
1、单条数据结果集的处理(RowCallbackHandler) public Agent getAgent(final int id) { String sql = "select * from t_agent where id = ?"; final Agent agent = new Agent(); jdbcTemplate.query(sql
Spring JdbcTemplate.queryForList()
热门推荐
allway2的博客
10-30 1万+
在本文中，我们将学习使用方法。queryForList()方法执行给定的 SQL 并返回结果List对象。queryForList()方法通过以下方式接受参数。执行给定的静态查询并返回一个列表。它使用 JDBC Statement语句，而不是 PreparedStatement。结果列表包含映射。一个映射实例表示一行，其中映射键是列名，映射值是列值。执行给定的静态查询并返回一个列表。它使用 JDBC Statement语句，而不是PreparedStatement。
Spring系列文章：Spring使用JdbcTemplate
最新发布
程序三两行
09-08 1665
JdbcTemplate是Spring提供的⼀个JDBC模板类，是对JDBC的封装，简化JDBC代码。当然，你也可以不⽤，可以让Spring集成其它的ORM框架，例如：MyBatis、Hibernate等。第一步：引入依赖。
关于mysql 数据库使用spring 2.0低版本 JdbcTemplate.queryForList 查询结果别名不起作用的解决方法
勇者无难
09-17 1803
根据mysql jdbc驱动程序中com.mysql.jdbc.ResultSetMetaData
Spring JdbcTemplate详解及项目中的运用
weixin_34280237的博客
06-12 230
1.Spring对不同的持久化支持： Spring为各种支持的持久化技术，都提供了简单操作的模板和回调 ORM持久化技术 模板类 JDBC org.springframework.jdbc.core.JdbcTemplate Hibernate5.0 org.springframework.orm.hibernate5.HibernateTemplate ...
Spring系列3--JdbcTemplate&事务
weixin_40988088的博客
10-21 283
4. JdbcTemplate 4.1 概念 JdbcTemplate是Spring框架对JDBC进行了封装，便于数据库操作。 4.2 使用 1. 引入依赖 spring的依赖：spring-jdbc、spring-tx、spring-orm 数据库的依赖：mysql-connector-java druid 2. 在spring配置文件中配置数据库连接池 3. 配置JdbcTemplate对象，设置dataSource，并注入spring容器 4.创建service类，dao类，在d
jdbcTemplate.queryForList 错误 spring-org.springframework.jdbc.IncorrectResultSetColumnCountException
qq_39393805的博客
09-28 1074
在使用queryForList想要获取一个List&lt;T&gt;时，使用jdbcTemplate.queryForList(Sql,T.class)； 会报IncorrectResultSetColumnCountException错误，而使用 //SQL语句 String SQL_SELECT = "select * from stu;"; 错误代码如下： //错误代码 Inco...
调用 jdbcTemplate.queryForList 时出现错误 spring-org.springframework.jdbc.IncorrectResultSetColumnCountExce...
weixin_30751947的博客
11-17 129
国内私募机构九鼎控股打造APP，来就送20元现金领取地址：http://jdb.jiudingcapital.com/phone.html内部邀请码：C8E245J（不写邀请码，没有现金送）国内私募机构九鼎控股打造，九鼎投资是在全国股份转让系统挂牌的公众公司，股票代码为430719，为“中国PE第一股”，市值超1000亿元。 ---------------------------...
Spring使用JdbcTemplate操作数据库附源码解释
Javaesandyou的博客
12-09 1505
目录 1.JdbcTemplate概述 2.JdbcTemplate准备工作 引入相关 jar 包 如果是maven项目，使用pom.xml代替引入jar包的过程（注意） 配置xml配置文件 3.JdbcTemplate 操作数据库 准备好数据库uset_db创建一个t_user表 对应数据库创建User实体类 创建UserDao接口并创建UserDaoImpl类 创建UserService类并在其中注入UserDao 编写测试类进行测试 4.JdbcTemplate源码解释 jdbc
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值