spring学习（四）spring的jdbcTemplate（增删改查封装）

Spring的jdbcTemplate操作

1、Spring框架一站式框架

（1）针对javaee三层，每一层都有解决技术

（2）到dao 层，使用 jdbcTemplate

2、Spring对不同的持久化都进行了封装

　　（1）jdbcTemplate  对  jdbc 进行封装

3、jdbcTemplate 使用和 dbutils 使用很相似，都是对数据库进行 crud 操作

4、使用jdbcTemplate 实现增删改查操作

增加：

　　1、导入 jdbcTemplate 相关jar 包

　　一定要导入相关数据库驱动的  jar 包

　　2、创建对象，设置数据库信息

　　3、创建jdbcTemplate 对象，设置数据源

　　4、调用 jdbcTemplate 对象里面的方法实现操作

//1、增加操作
    @Test
    public void add(){
        //创建对象，设置数据库信息
        DriverManagerDataSource dataSource=new DriverManagerDataSource();
        dataSource.setDriverClassName("com.mysql.jdbc.Driver");
        dataSource.setUrl("jdbc:mysql://localhost:3306/url_data");
        dataSource.setUsername("root");
        dataSource.setPassword("123");
        //创建jdbcTemplate 对象，设置数据源
        JdbcTemplate jdbcTemplate=new JdbcTemplate(dataSource);
        //调用 jdbcTemplate 对象里面的方法实现操作
        //c创建sql语句
        String sql="insert into user values(?,?)";
        int row=jdbcTemplate.update(sql, "zhansan","man");
        System.out.println("JdbcTemplateDemo1.add()"+row);
    }

修改：

    // 2、修改操作
    @Test
    public void update() {
        // 创建对象，设置数据库信息
        DriverManagerDataSource dataSource = new DriverManagerDataSource();
        dataSource.setDriverClassName("com.mysql.jdbc.Driver");
        dataSource.setUrl("jdbc:mysql://localhost:3306/url_data");
        dataSource.setUsername("root");
        dataSource.setPassword("123");
        // 创建jdbcTemplate 对象，设置数据源
        JdbcTemplate jdbcTemplate = new JdbcTemplate(dataSource);
        // 调用 jdbcTemplate 对象里面的方法实现操作
        // c创建sql语句
        String sql = "update user set sex=? where name=?";
        int row = jdbcTemplate.update(sql, "woman","zhangsan");
        System.out.println("JdbcTemplateDemo1.add()=" + row);
    }

删除：

    // 3、删除操作
    @Test
    public void delete() {
        DriverManagerDataSource dataSource = new DriverManagerDataSource();
        dataSource.setDriverClassName("com.mysql.jdbc.Driver");
        dataSource.setUrl("jdbc:mysql://localhost:3306/url_data");
        dataSource.setUsername("root");
        dataSource.setPassword("123");
        // 创建jdbcTemplate 对象，设置数据源
        JdbcTemplate jdbcTemplate = new JdbcTemplate(dataSource);
        // 调用 jdbcTemplate 对象里面的方法实现操作
        // c创建sql语句
        String sql = "delete from user where name=?";
        int row = jdbcTemplate.update(sql, "zhangsan");
        System.out.println("JdbcTemplateDemo1.add()=" + row);
    }

查看：

jdbcutil  用于 jdbcTemplate 的区别
    /*
     * (1)jdbcutils
     *  QueryRunner  runner = new QueryRunner(datasource);
     *
     *  返回对象
     *  runner.query(sql, new BeanHandler<User>(User.class));
     *
     *  返回list
     *  runner.query(sql, new BeanListHandler<User>(User.class));
     *
     * (2)jdbcTemplate实现查询，有接口RowMapper
     * jdbcTemplate针对这个接口没有实现具体的类，得到不同类型的数据需要自己心境数据的封装
     */

（1）查询返回某一个值

public void count() {
        DriverManagerDataSource dataSource = new DriverManagerDataSource();
        dataSource.setDriverClassName("com.mysql.jdbc.Driver");
        dataSource.setUrl("jdbc:mysql://localhost:3306/url_data");
        dataSource.setUsername("root");
        dataSource.setPassword("123");
        // 创建jdbcTemplate 对象，设置数据源
        JdbcTemplate jdbcTemplate = new JdbcTemplate(dataSource);
        String sql="select count(*) from user";
        //第一个参数是sql 语句
        //迭戈参数 返回类型的class
        int count=jdbcTemplate.queryForObject(sql, Integer.class);
        System.out.println(count);
    }

（2）查询返回某一个对象

原始方式：

//原始方式
public void testJdbc() throws SQLException {
        Connection conn=null;
        PreparedStatement pstmt=null;
        ResultSet rs=null;
        //加载驱动
        try {
            Class.forName("com.mysql.jdbc.Driver");
            //创建连接
            conn=(Connection) DriverManager.getConnection("jdbc:mysql://localhost/url_data", "root", "123");
            String sql="select * from user where username=?";
            //预编译
            pstmt=(PreparedStatement) conn.prepareStatement(sql);
            pstmt.setString(1, "lisi");
            rs=pstmt.executeQuery();
            //遍历结果集
            while(rs.next()){
                //得到返回的结果值
                String name=rs.getString("username");
                String sex=rs.getString("sex");
                User user=new User();
                user.setUsername(name);
                user.setSex(sex);
                System.out.println(user);
            }
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        } catch (SQLException e) {
            e.printStackTrace();
        }finally{
                rs.close();
                pstmt.close();
                conn.close();
        }
    }

jdbc 方式：

    @Test
    public void FindObject() {
        DriverManagerDataSource dataSource = new DriverManagerDataSource();
        dataSource.setDriverClassName("com.mysql.jdbc.Driver");
        dataSource.setUrl("jdbc:mysql://localhost:3306/url_data");
        dataSource.setUsername("root");
        dataSource.setPassword("123");
        // 创建jdbcTemplate 对象，设置数据源
        JdbcTemplate jdbcTemplate = new JdbcTemplate(dataSource);
        String sql="select * from user where name=?";
        //调用jdbcTemplate
        //第一个参数：sql语句
        //第二个人参数：类似于 dbutils 中的接口RowMapper,需要自己写实现类，实现具体方法，实现数据封装
        //第三个参数： 可变参数（sql中传的值）
        User user = jdbcTemplate.queryForObject(sql, new MyRowMapper(),"lisi");
        System.out.println(user.getName());
    }

写一个非public class

class MyRowMapper implements RowMapper<User>{

    //num:行号
    public User mapRow(ResultSet rs, int index) throws SQLException {
        //1、从结果集里面把数据得到
        String name=rs.getString("name");
        String sex=rs.getString("sex");
        //2、把没我们得到的数据封装到对象里面
        User user=new User();
        user.setName(name);
        user.setSex(sex);
        return user;
    }

}
匿名内部类

（3）查询返回 list 集合

    public void FindList(){
        DriverManagerDataSource dataSource = new DriverManagerDataSource();
        dataSource.setDriverClassName("com.mysql.jdbc.Driver");
        dataSource.setUrl("jdbc:mysql://localhost:3306/url_data");
        dataSource.setUsername("root");
        dataSource.setPassword("123");
        // 创建jdbcTemplate 对象，设置数据源
        JdbcTemplate jdbcTemplate = new JdbcTemplate(dataSource);
        String sql="select * from user";
        //调用jdbcTemplate
        //第一个参数：sql 语句
        //第二个参数RowMapper 接口
        //第三个参数：可变参数,可以省略
        List<User> list=jdbcTemplate.query(sql, new MyRowMapperList());
        for(int i=0;i<list.size();i++){
            System.out.println(list.get(i));
        }
    }

实现RowMapper类

class MyRowMapperList implements RowMapper<User>{

    //index:行号
    public User mapRow(ResultSet rs, int index) throws SQLException {
        //1、从结果集里面把数据得到
        String name=rs.getString("name");
        String sex=rs.getString("sex");
        //2、把没我们得到的数据封装到对象里面
        User user=new User();
        user.setName(name);
        user.setSex(sex);
        return user;
    }

5、Spring 配置 c3p0 连接池 和dao  使用jdbcTemplate

（1）Spring 配置 c3p0 连接池

　　- 导入 jar 包

　　

原始的 c3p0 写法

        ComboPooledDataSource datasource=new ComboPooledDataSource();
        datasource.setDriverClass("com.mysql.jdbc.Driver");
        datasource.setJdbcUrl("jdbc:mysql://localhost:3306/url_data");
        datasource.setUser("root");
        datasource.setPassword("123");

在xml中配置 c3p0

		<!-- 配置  c3p0 -->
		<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/url_data"></property>
			<property name="user" value="root"></property>
			<property name="password" value="123"></property>
		</bean>

　　

（2）dao  使用jdbcTemplate

　　 1、创建 service 和 dao 对象，配置 service  和 dao 对象

　　2、创建 JdbcTemplate 对象，把 模板对象注入到 dao 里面

　　3、在 jdbcTemplate 对象里面注入 dataSource 对象

Service类

package cn.itcast.c3p0;

public class UserService {

    private UserDao userDao;

    public void setUserDao(UserDao userDao) {
        this.userDao = userDao;
    }

    public void add(){
        System.out.println("service add.....");
        userDao.add();
    }
}

dao类

package cn.itcast.c3p0;

import org.springframework.jdbc.core.JdbcTemplate;

public class UserDao {

    //要得到jdbcTemplate 对象
    private JdbcTemplate jdbcTemplate;

　　　　public void setJdbcTemplate(JdbcTemplate jdbcTemplate) {
　　　　　　this.jdbcTemplate = jdbcTemplate;
　　　　}

public void add(){
        String sql="insert into user values(?,?)";
        jdbcTemplate.update(sql,"大力","man");
    }
}

c3p0.xml 配置：

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

        <!-- 配置  c3p0 -->
        <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/url_data"></property>
            <property name="user" value="root"></property>
            <property name="password" value="123"></property>
        </bean>
        <!-- 创建service 和 Dao。在Service 中调用dao -->

        <bean id="userService" class="cn.itcast.c3p0.UserService">
            <!-- 注入Dao -->
            <property name="userDao" ref="userDao"></property>
        </bean>

        <bean id="userDao" class="cn.itcast.c3p0.UserDao">
            <!-- 注入jdbctemplate对象 -->
            <property name="jdbcTemplate" ref="jdbcTemplate"></property>
        </bean>

        <!-- 创建JdbcTemplate对象 -->
        <bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">
            <!-- 把dataSource 传到 jdbcTemplate里面-->
            <property name="dataSource" ref="dataSource"></property>
        </bean>
</beans>

测试：

    public void testC(){
        ApplicationContext context=new ClassPathXmlApplicationContext("c3p0.xml");
        UserService userService=(UserService) context.getBean("userService");
        userService.add();
    }

测试结果：

在数据库 user 表里添加一条数据

时间： 2024-10-25 05:14:21

spring学习（四）spring的jdbcTemplate（增删改查封装）的相关文章

JdbcTemplate增删改查

1.使用JdbcTemplate的execute()方法执行SQL语句 Java代码   jdbcTemplate.execute("CREATE TABLE USER (user_id integer, name varchar(100))"); 2.如果是UPDATE或INSERT,可以用update()方法. Java代码   jdbcTemplate.update("INSERT INTO USER VALUES('" + user.getId() + &q

Hibernate的四种典型例子(增删改查)

Hibernate的四种典型例子(增删改查)  //查询  // Session session=HibernateSessionFactory.getSession();  // session.beginTransaction();  // Query q=session.createQuery("from Info where id=:id");  // q.setInteger("id", 1);  // List l=q.list();  // Info

Mysql学习笔记（六）增删改查

原文:Mysql学习笔记(六)增删改查 PS:数据库最基本的操作就是增删改查了... 学习内容: 数据库的增删改查 1.增...其实就是向数据库中插入数据.. 插入语句 insert into table_name values("要插入的数据"); 比如说,我们先创建一个宠物表,用来记录宠物的基本信息以及所有者... create table pet ( name varchar(20), owner varchar(20), species varchar(20), sex cha

spring boot(9) redis(连接，增删改查，集群，和session一起使用)

1.建立连接 1.1 pom.xml <!-- redis 相关支持 --> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-redis</artifactId> <version>1.3.2.RELEASE</version> </dependency> 1.2 app

JdbcTemplate(增删改查以及以注释实现增删改查)

JdbcTemplate介绍 为了使 JDBC 更加易于使用,Spring 在 JDBCAPI 上定义了一个抽象层, 以此建立一个JDBC存取框架,Spring Boot Spring Data-JPA. 作为 SpringJDBC 框架的核心, JDBC 模板的设计目的是为不同类型的JDBC操作提供模板方法. 每个模板方法都能控制整个过程,并允许覆盖过程中的特定任务. 通过这种方式,可以在尽可能保留灵活性的情况下,将数据库存取的工作量降到最低. JdbcTemplate方法介绍 execute

MVC3+EF4.1学习系列(二)-------基础的增删改查和持久对象的生命周期变化

上篇文章中 我们已经创建了EF4.1基于code first的例子  有了数据库 并初始化了一些数据  今天这里写基础的增删改查和持久对象的生命周期变化 学习下原文先把运行好的原图贴来上~~ 一.创建详细页 首先 我们先在控制器下 添加详细页的方法 因为这篇文章后面要介绍持久对象声明周期的变化 所以在这里先看下有哪些状态 EF里一共有这五中生命状态类型 其实 看名字我们可以大概猜测出个一二三来~~  游离的 未改变的  新添加的  已删除的 修改的  但是是怎么变化的能 我们在后面的代码中实践与

python之MySQL学习——简单的增删改查封装

1.增删改查封装类MysqlHelper.py 1 import pymysql as ps 2 3 class MysqlHelper: 4 def __init__(self, host, user, password, database, charset): 5 self.host = host 6 self.user = user 7 self.password = password 8 self.database = database 9 self.charset = charset

Python学习---django之ORM的增删改查180125

模型常用的字段类型参数 <1> CharField        #字符串字段, 用于较短的字符串.        #CharField 要求必须有一个参数 maxlength, 用于从数据库层和Django校验层限制该字段所允许的最大字符数.<2> IntegerField       #用于保存一个整数.<3> FloatField        # 一个浮点数. 必须 提供两个参数:    参数    描述        # max_digits    总位数(不

django框架学习：12.数据操作增删改查

前言 django的modles模块里可以新增一张表和字段,通常页面的操作都是源于数据库的增删改查,怎样通过django实现数据库的增删改查呢? 数据库新增数据 上一篇我们创建了ke24_user表,将use_name ="liushui",psw ="123456",mail = "[email protected]" 在urls同级目录下创建testdb.py 文件,创建add_user方法如下: 给上面创建的方法在urls.py创建一个访问