时间：2017-2-5 18:16

——Spring对不同持久化技术的支持

Spring为各种支持的持久化技术都提供了简单操作的模板和回调。

ORM持久化技术：
    JDBC：
        org.springframework.jdbc.core.JdbcTemplate

    Hibernate3.0：
        org.springframework.orm.hibernate3.HibernateTemplate
 
    IBatis（MyBatis）：
        org.springframework.orm.ibatis.SqlMapClientTemplate
 
    JPA：
        org.springframework.orm.jpa.JpaTemplate
 
——JDBC Template

1、Spring JDBC是Spring提供的持久层技术。
2、简化JDBC API的开发，使用上和Apache公司的DBUtils框架非常相似。
3、导入必要jar包到工程目录。
4、导入Spring核心开发包
    >   spring-beans-3.2.0.RELEASE.jar

    >   spring-context-3.2.0.RELEASE.jar
    >   spring-core-3.2.0.RELEASE.jar
    >   spring-expression-3.2.0.RELEASE.jar
5、导入commons-logging日志包

>   commons-logging-1.1.1.jar

6、导入JDBC模板开发包
    >   spring-jdbc-3.2.0.RELEASE.jar

        JDBC工具。
    >   spring-tx-3.2.0.RELEASE.jar
        事务管理。
7、导入MySQL驱动

——JDBC Template入门

1、导入相应jar包
    *   spring-jdbc-3.2.0.RELEASE.jar
    *   spring-tx-3.2.0.RELEASE.jar
    *   mysql-connector-java-5.1.35-bin.jar
    *   mchange-commons-java-0.2.3.4.jar

2、创建applicationContext.xml配置文件

3、编写一个测试类

import org.junit.Test;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.jdbc.datasource.DriverManagerDataSource;
 
public class SpringDemo1 {
 
    @Test
    public void fun1(){
        // 创建连接池
        DriverManagerDataSource dataSource = new DriverManagerDataSource();

        // 设置参数
        dataSource.setDriverClassName("com.mysql.jdbc.Driver");
        dataSource.setUrl("jdbc:mysql:///spring3_day02");
        dataSource.setUsername("root");
        dataSource.setPassword("Admin123");
 
        // 使用JDBC的模板
        JdbcTemplate jdbcTemplate = new JdbcTemplate(dataSource);

        // 执行SQL语句
        jdbcTemplate.execute("create table User (id int primary key auto_increment, name varchar(20))");
    }
}

——使用Spring默认连接池

从刚刚的示例中已经看出，Spring JDBC模板的使用，必须依赖DataSource数据库连接池。

在实际开发中，通常使用Spring配置文件来配置JDBC Template。

常用数据源：
    1）Spring数据源实现类：DriverManagerDataSource
    2）DBCP数据源：BasicDataSource
    3）C3P0数据源：ComboPooledDataSource

1、创建applicationContext.xml配置文件

<?xml version="1.0" encoding="UTF-8"?>
    xsi:schemaLocation="
 
    <!-- Spring默认连接池 -->
    <bean id="dataSource" class="org.springframework.jdbc.datasource.DriverManagerDataSource">
        <property name="url" value="jdbc:mysql:///spring3_day02" />
        <property name="username" value="root" />
        <property name="password" value="Admin123" />
    </bean>
 
 
    <!-- 定义JDBCTemplate类 -->
    <!-- 为JDBC模板注入连接池属性 -->
    <bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate" >
        <property name="dataSource" ref="dataSource" />
    </bean>
</beans>

2、测试代码：

    @Test
    public void fun(){
        ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
        jdbcTemplate.execute("create table User3 (id int primary key auto_increment, name varchar(20))");
    }

——DBCP连接池

1、导入相应jar包
    *   com.springsource.org.apache.commons.dbcp-1.2.2.osgi.jar
    *   com.springsource.org.apache.commons.pool-1.5.3.jar

2、创建配置文件

<?xml version="1.0" encoding="UTF-8"?>
    xsi:schemaLocation="
 
    <!-- 配置DBCP连接池 -->
    <bean id="dataSource" class="org.apache.commons.dbcp.BasicDataSource">
        <property name="driverClassName" value="com.mysql.jdbc.Driver" />
        <property name="url" value="jdbc:mysql:///spring3_day02" />
        <property name="username" value="root" />
        <property name="password" value="Admin123" />
    </bean>
    <!-- 定义JDBCTemplate类 -->
    <!-- 为JDBC模板注入连接池属性 -->
    <bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate" >
        <property name="dataSource" ref="dataSource" />
    </bean>
 
</beans>

3、测试代码

    @Test
    public void fun(){
        ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
        jdbcTemplate.execute("create table User4 (id int primary key auto_increment, name varchar(20))");
    }

——C3P0连接池

1、导入相应jar包
    *   com.springsource.com.mchange.v2.c3p0-0.9.1.2.jar

2、创建配置文件

<?xml version="1.0" encoding="UTF-8"?>
    xsi:schemaLocation="
    <!-- 配置C3P0连接池 -->
    <bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
        <property name="driverClass" value="com.mysql.jdbc.Driver" />
        <property name="jdbcUrl" value="jdbc:mysql:///spring3_day02" />
        <property name="user" value="root" />
        <property name="password" value="Admin123" />
 
    </bean>
 
    <!-- 定义JDBCTemplate类 -->
    <!-- 为JDBC模板注入连接池属性 -->
    <bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate" >
        <property name="dataSource" ref="dataSource" />
    </bean>
 
</beans>
 

3、测试代码

    public void fun(){
        ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
        jdbcTemplate.execute("create table User5 (id int primary key auto_increment, name varchar(20))");
    }

——将参数配置到属性文件中

1、在src下创建jdbc.properties属性文件
    jdbc.driver = com.mysql.jdbc.Driver

    jdbc.url = jdbc:mysql:///spring3_day02
    jdbc.username = root
    jdbc.password = Admin123

2、在applicationContext.xml中使用属性文件配置的内容
    1）第一种写法
        <?xml version="1.0" encoding="UTF-8"?>

        <beans xmlns="http://www.springframework.org/schema/beans"
            xmlns:context="http://www.springframework.org/schema/context"
 

<bean

                class="org.springframework.beans.factory.config.PropertyPlaceholderConfigurer">
                <property name="location" value="classpath:jdbc.properties" />
            </bean>
 
 
            <!-- 配置C3P0连接池 -->
            <bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
                <property name="driverClass" value="${jdbc.driver}" />
                <property name="jdbcUrl" value="${jdbc.url}" />
                <property name="user" value="${jdbc.username}" />
                <property name="password" value="${jdbc.password}" />

</bean>

            <!-- 定义JDBCTemplate类 -->

            <!-- 为JDBC模板注入连接池属性 -->
            <bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">
                <property name="dataSource" ref="dataSource" />
            </bean>
 
        </beans>

2）第二种写法
        <?xml version="1.0" encoding="UTF-8"?>

        <beans xmlns="http://www.springframework.org/schema/beans"
            xmlns:context="http://www.springframework.org/schema/context"
 
            <context:property-placeholder location="classpath:jdbc.properties"/>
 
            <!-- 配置C3P0连接池 -->
            <bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
                <property name="driverClass" value="${jdbc.driver}" />
                <property name="jdbcUrl" value="${jdbc.url}" />
                <property name="user" value="${jdbc.username}" />
                <property name="password" value="${jdbc.password}" />
            </bean>
 
            <!-- 定义JDBCTemplate类 -->
            <!-- 为JDBC模板注入连接池属性 -->
            <bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">
                <property name="dataSource" ref="dataSource" />
            </bean>
        </beans>
 

——JDBCTemplate的CRUD操作

1、为了方便Dao中注入JDBC Template，Spring为每一个持久化技术都提供了支持类。
    1）JDBC：
        org.springframework.jdbc.core.support.JdbcDaoSupport

    2）Hibernate 3.0：
        org.springframework.orm.hibernate3.support.HibernateDaoSupport
    3）iBatis：
        org.springframework.orm.ibatis.support.SqlMapClientDaoSupport

2、编写Dao，并继承JdbcDaoSupport类。
    JdbcDaoSupport中提供了JDBCTemplate实例，所以在自己的Dao中不需要再定义JDBCTemplate并且提供注入了，可以直接使用getJdbcTemplate()方法来获取实例。

3、进行CUD操作
    1）保存：update(String sql, Object ... args)
    2）修改：update(String sql, Object ... args)
    3）删除：update(String sql, Object ... args)

4、查询操作
    1）简单查询
        *   select count(*) from user
            >   queryForLong(String sql)
            >   返回一个简单类型 
        *   select name from user where id = ?
            >   queryForObject(String sql, Class, Object...args)
            >   返回单个对象 

    2）复杂查询
        返回对象或集合。
        *   select * from user where id = ?
            >   queryForObject(String sql, RowMapper<T> rowMapper, Object...args)
            >   返回单个对象 
        *   select * from user
            >   query(String sql, RowMapper<T> rowMapper, Object ... args)
            >   返回多个对象 

5、示例代码

User实体类：

public class User {
    private Integer id;
    private String name;
 
    public Integer getId() {
        return id;
    }
 
    public void setId(Integer id) {
        this.id = id;
    }
 
    public String getName() {
        return name;
    }
 
    public void setName(String name) {
        this.name = name;
    }
 
    @Override
    public String toString() {
        return "User [id=" + id + ", name=" + name + "]";
    }
}

----------------------------------------------------------------------------------------------------------------------------

UserDao：

import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.List;
 
import org.springframework.jdbc.core.RowMapper;
import org.springframework.jdbc.core.support.JdbcDaoSupport;
 
public class UserDao extends JdbcDaoSupport {
 
 
    public void add(User user) {
        String sql = "insert into user values (null, ?)";
        // 因为JdbcDaoSupport中提供了JdbcTemplate，所以可以直接get获取
        getJdbcTemplate().update(sql, user.getName());
    }
 
    public void update(User user) {
        String sql = "update user set name = ? where id = ?";
        getJdbcTemplate().update(sql, user.getName(), user.getId());
    }
 
    public void delete(User user) {
        String sql = "delete from user where id = ?";
        getJdbcTemplate().update(sql, user.getId());
    }
 
    public long findCount(){
        String sql = "select count(*) from user";
        return getJdbcTemplate().queryForLong(sql);
    }
 
    public String findNameById(int id){
        String sql = "select name from user where id = ?";
        return getJdbcTemplate().queryForObject(sql, String.class, id);
    }
 
    public User findById(int id){
        String sql = "select * from user where id = ?";
        return (User) getJdbcTemplate().queryForObject(sql,new UserRowMapper(), id);
    }
 
    class UserRowMapper implements RowMapper<User>{
        /**
         * rs：结果集
         * rowNum：行号
         * 需要自己提供RowMapper实现，用来将记录封装成对象 
         */
        public User mapRow(ResultSet rs, int rowNum) throws SQLException {
            User user = new User();
            user.setId(rs.getInt("id"));
            user.setName(rs.getString("name"));
            return user;
        }
    }
 
    public List<User> findAll(){
        String sql = "select * from user";
        return getJdbcTemplate().query(sql, new UserRowMapper());
    }
}

----------------------------------------------------------------------------------------------------------------------------

XML配置文件：

<?xml version="1.0" encoding="UTF-8"?>
 
    <context:property-placeholder location="classpath:jdbc.properties" />
 
 
    <!-- 配置C3P0连接池 -->
    <bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
        <property name="driverClass" value="${jdbc.driver}" />
        <property name="jdbcUrl" value="${jdbc.url}" />
        <property name="user" value="${jdbc.username}" />
        <property name="password" value="${jdbc.password}" />
    </bean>
 
    <!-- 定义JDBCTemplate类 -->
    <!-- 为JDBC模板注入连接池属性 -->
    <bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">
        <property name="dataSource" ref="dataSource" />
    </bean>
 
    <bean id="userDao" class="com.wyc.spring3.demo2.UserDao">
        <property name="jdbcTemplate" ref="jdbcTemplate" />
    </bean>
 
</beans>
 

----------------------------------------------------------------------------------------------------------------------------

测试代码：

import java.util.List;
 
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
 
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration("classpath:applicationContext.xml")
public class SpringDemo2 {
 
    @Autowired
    @Qualifier("userDao")
    private UserDao userDao;
 
    @Test
    // 添加
    public void fun1() {
        User user = new User();
        user.setName("王五");
        userDao.add(user);
    }
 
    @Test
    // 修改
    public void fun2() {
        User user = new User();
        user.setId(1);
        user.setName("李四");
        userDao.update(user);
    }
 
    @Test
    // 删除
    public void fun3() {
        User user = new User();
        user.setId(1);
        userDao.delete(user);
    }
 
    @Test
    // 查询记录数量
    public void fun4() {
        System.out.println(userDao.findCount());
    }
 
    @Test
    // 查询姓名
    public void fun5() {
        System.out.println(userDao.findNameById(2));
    }
 
    @Test
    // 查询单个对象
    public void fun6() {
        System.out.println(userDao.findById(3));
    }
 
    @Test
    // 查询全部对象
    public void fun7() {
        List<User> list = userDao.findAll();
        for (User user : list) {
            System.out.println(user);
        }
    }
}

——总结

1、配置连接池：
     1）默认连接池
    2）DBCP连接池
    3）C3P0连接池
        *   提取properties文件
2、JdbcTemplate的CRUD操作 

Dao继承JdbcDaoSupport之后，可以不在Dao中注入JdbcTemplate对象了，因为JdbcDaoSupport中已经定义了JdbcTemplate实例。

Spring之JDBC Template的更多相关文章

  1. SSM 实训笔记 -11- 使用 Spring MVC + JDBC Template 实现筛选、检索功能（maven）

    SSM 实训笔记 -11- 使用 Spring MVC + JDBC Template 实现筛选.检索功能(maven) 本篇是新建的一个数据库,新建的一个完整项目. 本篇内容: (1)使用 Spri ...

  2. Spring的JDBC Template

    Spring的JDBC Template(JDBC模板)简化JDBC API开发,使用上和Apache公司的DBUtils框架非常类似) 快速入门实例 1.创建项目后,导入Spring基础核心开发包. ...

  3. Spring中jdbc Template使用

    http://1358440610-qq-com.iteye.com/blog/1826816

  4. Spring框架学习10——JDBC Template 实现数据库操作

    为了简化持久化操作,Spring在JDBC API之上提供了JDBC Template组件. 1.添加依赖 添加Spring核心依赖,MySQL驱动 <!--Spring核心基础依赖--> ...

  5. Unit06： Spring对JDBC的 整合支持 、 Spring+JDBC Template、Spring异常处理

    Unit06: Spring对JDBC的 整合支持 . Spring+JDBC Template .Spring异常处理 1. springmvc提供的异常处理机制 我们可以将异常抛给spring框架 ...

  6. spring学习笔记之---JDBC Template

    JDBC  Template(简化持久化操作) (一)创建项目 (1)Maven配置 <dependencies> <dependency> <groupId>ju ...

  7. spring+jdbc+template+transaction实现

    使用spring和jdbc模板事务实现 1.创建实体类: Role package com.wbg.sjt.entity; public class Role { private int id; pr ...

  8. spring 整合JDBC

    使用Spring提供的三个JDBC模板类(JdbcTemplate.NamedParameterJdbcTemplate.SimpleJdbcTemplate)操作数据库 一.JdbcTemplate ...

  9. Spring第七篇【Spring的JDBC模块】

    前言 上一篇Spring博文主要讲解了如何使用Spring来实现AOP编程,本博文主要讲解Spring的对JDBC的支持- 对于JDBC而言,我们肯定不会陌生,我们在初学的时候肯定写过非常非常多的JD ...

随机推荐

  1. 【剑指offer】05. 替换空格

    剑指 Offer 05. 替换空格 知识点:: 题目描述 请实现一个函数,把字符串 s 中的每个空格替换成"%20". 示例 输入:s = "We are happy.& ...

  2. uni-app&H5&Android混合开发三 || uni-app调用Android原生方法的三种方式

    前言: 关于H5的调用Android原生方法的方式有很多,在该片文章中我主要简单介绍三种与Android原生方法交互的方式. 一.H5+方法调用android原生方法 H5+ Android开发规范官 ...

  3. HTMLTestRunner.py 文件，已修改完成

    """ A TestRunner for use with the Python unit testing framework. It generates a HTML ...

  4. odoo14里面的消息机制

    odoo里面 字段追踪.消息通知机制:  一.使用方式:1.在定义模型的py文件里继承mail模型 class DemoModle(models.Model): """ ...

  5. c++ 父类 子类 虚表占用内存空间情况

    #include <iostream> using namespace std; class C {}; class A:public C { private: long a; long ...

  6. react native踩坑记录

    一 .安装 1.Python2 和Java SE Development Kit (JDK)可以直接通过腾讯电脑关键安装, Android SDK安装的时候路径里不能有中文和空格 2.配置java环境 ...

  7. Android 开发必备的知识点——JVM基础【转】

    image 1.JVM与操作系统的关系 Java Virtual Machine JVM 全称 Java Virtual Machine,也就是我们耳熟能详的 Java 虚拟机.它能识别 .class ...

  8. InnoDB锁机制-转载

    InnoDB锁机制 1. 锁类型 锁是数据库区别与文件系统的一个关键特性,锁机制用于管理对共享资源的并发访问. InnoDB使用的锁类型,分别有: 共享锁(S)和排他锁(X) 意向锁(IS和IX) 自 ...

  9. Mongodb集成LDAP授权

    一.环境简介 Mongodb enterprise v4.0.16 OpenLDAP v2.4.44 二.Mongodb集成LDAP的授权过程 客户端指定某种外部验证方式链接Mongodb: Mong ...

  10. OpenGL学习笔记（四）纹理

    目录 要完成的纹理效果 纹理环绕方式 纹理过滤 多级渐远纹理 加载与创建纹理 stb_image库的使用方法 生成纹理对象 应用纹理 纹理单元 参考资料:OpenGL中文翻译 要完成的纹理效果 纹理是 ...