【Spring】对持久层技术的整合

  • 一、持久层技术
  • 二、JdbcTemplate
    • 开发步骤：

      • 1. 导入相关的jar包
      • 2. 配置连接池(数据源)
        • 将参数设置到属性文件中:
      • 3. 创建表
      • 4. 编写实体类
      • 5. Dao层实现
        • 5.1 继承JdbcDaoSupport
        • 5.2 直接注入JdbcTmplate
      • 6. 测试
    • JdbcTemplate 的CRUD(待整理)
  • 三、Hibernate
  • 四、MyBatis

一、持久层技术

  1. Spring 中自带的 JdbcTemplate
  2. Hibernate
  3. Mybatis

二、JdbcTemplate

开发步骤：

1. 导入相关的jar包

<!-- https://mvnrepository.com/artifact/org.springframework/spring-jdbc -->
<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-jdbc</artifactId>
    <version>5.1.5.RELEASE</version>
</dependency>

<!-- https://mvnrepository.com/artifact/mysql/mysql-connector-java -->
<dependency>
    <groupId>mysql</groupId>
    <artifactId>mysql-connector-java</artifactId>
    <version>8.0.13</version>
</dependency>

2. 配置连接池(数据源)

　　创建一个数据库test

  • Spring默认的连接池:
<!-- 配置Spring默认的连接池 -->
<bean id="dataSource" class="org.springframework.jdbc.datasource.DriverManagerDataSource">
    <property name="driverClassName" value="com.mysql.jdbc.Driver"/>
    <property name="url" value="jdbc:mysql://localhost:3306/test"/>
    <property name="username" value="root"/>
    <property name="password" value="123"/>
</bean>
  • DBCP连接池:

　　引入Maven 坐标：

<!-- https://mvnrepository.com/artifact/commons-dbcp/commons-dbcp -->
<dependency>
    <groupId>commons-dbcp</groupId>
    <artifactId>commons-dbcp</artifactId>
    <version>1.4</version>
</dependency>

　　配置信息：

<!-- 配置DBCP连接池 -->
<bean id="dataSource" class="org.apache.commons.dbcp.BasicDataSource">
            <property name="driverClassName" value="com.mysql.jdbc.Driver"/>
    <property name="url" value="jdbc:mysql:///test"/>
    <property name="username" value="root"/>
    <property name="password" value="123"/>
</bean>
  • C3P0连接池:

　　引入Maven 坐标：

<!-- https://mvnrepository.com/artifact/c3p0/c3p0 -->
<dependency>
    <groupId>c3p0</groupId>
    <artifactId>c3p0</artifactId>
    <version>0.9.1.2</version>
</dependency>

　　配置信息：

<!-- 配置c3p0连接池 -->
<bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
    <property name="driverClass" value="com.mysql.jdbc.Driver"/>
    <property name="jdbcUrl" value="jdbc:mysql:///test"/>
    <property name="user" value="root"/>
    <property name="password" value="123"/>
</bean>
将参数设置到属性文件中:

属性文件jdbc.properties：

jdbc.driver = com.mysql.jdbc.Driver
jdbc.url = jdbc:mysql:///test
jdbc.user = root
jdbc.password = 123

需要在applicationContext.xml 中使用属性文件配置的内容.

  • 第一种写法:
<bean class="org.springframework.beans.factory.config.PropertyPlaceholderConfigurer">
    <property name="location" value="classpath:jdbc.properties"></property>
</bean>
  • 第二种写法:

　　需要引入context的命名空间：

<?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"
       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">

　　配置如下：

<context:property-placeholder location="classpath:jdbc.properties"/>

　　上面数据源的配置,属性的值就可以用${}来取出properties配置文件中的值

<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.user}"/>
    <property name="password" value="${jdbc.password}"/>
</bean>

3. 创建表

这里要注意的是创建的表名不能用users,

CREATE TABLE `member` (
`id` int(11) NOT NULL AUTO_INCREMENT,
`name` varchar(20) DEFAULT NULL,
`age` int(11) DEFAULT NULL,
  PRIMARY KEY (`id`)
) ENGINE=InnoDB

4. 编写实体类

public class Member {
    private Integer id;
    private String name;
    private Integer age;

    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;
    }

    public Integer getAge() {
        return age;
    }

    public void setAge(Integer age) {
        this.age = age;
    }

    @Override
    public String toString() {
        return "Member [id=" + id + ", name=" + name + ", age=" + age + "]";
    }
}

5. Dao层实现

5.1 继承JdbcDaoSupport

Spring框架中提供了对持久层技术支持的类: JdbcDaoSupport，这个类中依赖了JdbcTemplte模版而且自己实现了setter方法

　　编写DAO的时候要继承该类，如下：

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;

import com.hao.entity.Member;

public class MemberDao extends JdbcDaoSupport {

    /**
     * 添加用户
     *
     * @param member
     */
    public void add(Member member) {
        String sql = "insert into member values(null,?,?)";
        this.getJdbcTemplate().update(sql, member.getName(), member.getAge());
    }

    /**
     * 根据id更新用户名
     *
     * @param member
     */
    public void updateById(Member member) {
        String sql = "update member  set name = ? where id =?";
        this.getJdbcTemplate().update(sql, member.getName(), member.getId());
    }

    /**
     * 根据id删除用户
     *
     * @param member
     */
    public void deleteById(Member member) {
        String sql = "delete from member where id = ? ";
        this.getJdbcTemplate().update(sql, member.getId());
    }

    /**
     * 查询用户总数
     *
     * @return
     */
    public int findCount() {
        String sql = "select count(*) from member";
        // spring 3.2之后的版本不在支持queryInt(sql);
        return this.getJdbcTemplate().queryForObject(sql, int.class);
    }

    /**
     * 通过id查询用户名
     *
     * @param id
     * @return
     */
    public String findNameById(int id) {
        String sql = "select name from member where id = ?";
        return this.getJdbcTemplate().queryForObject(sql, String.class, id);
    }

    /**
     * 根据id查询用户
     *
     * @param id
     * @return
     */
    public Member findById(int id) {
        String sql = "select * from member where id = ?";
        Member member = this.getJdbcTemplate().queryForObject(sql, new UserRowMapper(), id);
        return member;
    }

    /**
     * 查询所有用户
     *
     * @return
     */
    public List<Member> findAll() {
        String sql = "select * from member";
        return this.getJdbcTemplate().query(sql, new UserRowMapper());

    }

    class UserRowMapper implements RowMapper<Member> {
        /**
         * rs:结果集. rowNum:行号
         */
        public Member mapRow(ResultSet rs, int rowNum) throws SQLException {
            Member member = new Member();
            member.setId(rs.getInt("id"));
            member.setName(rs.getString("name"));
            return member;
        }

    }
}

　　在XML中的配置，此种方式不需要再XML中声明jdbcTemplate ，只需要在Dao层注入数据源即可如下：

<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.user}"/>
        <property name="password" value="${jdbc.password}"/>
    </bean> 

    <!-- 此处直接注入数据源，因为Dao层中继承了JdbcDaoSupport这个类 -->
    <bean id="memberDao" class="com.hao.dao.MemberDao">
        <property name="dataSource" ref="dataSource"></property>
    </bean>
5.2 直接注入JdbcTmplate

public class MemberDaoForNoExtend {

    //利用setter的方法注入jdbcTmplate
    private JdbcTemplate jdbcTemplate;
    public void setJdbcTemplate(JdbcTemplate jdbcTemplate) {
        this.jdbcTemplate = jdbcTemplate;
    }

    /**
     * 添加用户
     *
     * @param member
     */
    public void add(Member member) {
        String sql = "insert into member values(null,?,?)";
        jdbcTemplate.update(sql, member.getName(), member.getAge());
    }

   // 后面的代码省略...

}

　　在XML中的配置，此种方式要在Dao层注入jdbcTemplate

<!-- 定义jdbctemplate 需要注入数据源 -->
<bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">
        <property name="dataSource" ref="dataSource"/>
</bean>
<!-- 定义Dao层类 需要注入jdbcTemplate-->
<bean id="memberDao" class="com.hao.dao.MemberDao">
        <property name="jdbcTemplate" ref="jdbcTemplate"></property>
</bean>

6. 测试

　　测试1 --> 5.1中的方式测试

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;

import com.hao.dao.MemberDao;
import com.hao.entity.Member;

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration("classpath:applicationContext1.xml")
public class JDBCTest1 {

    @Autowired
    @Qualifier("memberDao")
    private MemberDao memberDao;

    @Test
    public void test1() {
        Member member = new Member();
        member.setName("小涛");
        member.setAge(23);
        memberDao.add(member);
    }

    @Test
    public void test2() {
        int findCount = memberDao.findCount();
        System.out.println(findCount);
    }

    @Test
    public void test3() {
        Member member  = new Member();
        member.setId(12);
        memberDao.deleteById(member);
    }

}

　　测试2 --> 5.2中的方式测试

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration("classpath:applicationContext2.xml")
public class JDBCTest2 {

    @Autowired
    @Qualifier("memberDaoForNoExtend")
    private MemberDaoForNoExtend memberDaoForNoExtend;

    @Test
    public void test1() {
        Member member = new Member();
        member.setName("小明");
        member.setAge(23);
        memberDaoForNoExtend.add(member);
    }
}

JdbcTemplate 的CRUD(待整理)

  • 保存:update(String sql,Object... args)
  • 修改:update(String sql,Object... args)
  • 删除:update(String sql,Object... args)
  • 查询:
    • 简单查询:

      • queryForObject(String sql,Class clazz,Object... args);
    • 复杂查询:(返回对象,和对象集合)
      • queryForObjectString sql,RowMapper<T> rowMapper,Object... args);
      • query(String sql,RowMapper<T> rowMapper,Object... args);

三、Hibernate

org.springframework.orm.hibernate3.support.HibernateDaoSupport

四、MyBatis

org.springframework.orm.ibatis.support.SqlMapClientDaoSupport

原文地址：https://www.cnblogs.com/haoworld/p/spring-dui-chi-jiu-ceng-ji-shu-de-zheng-he.html

时间： 2024-08-06 13:07:41

【Spring】对持久层技术的整合的相关文章

对spring 对持久层的支持和数据库连接池的理解

1.spring对持久层的支持在于,得到数据库连接之后操作上的封装,将操作简化了.也就是说以后操作sql语句就用XXXTemplate对象了. 2.数据库连接池的作用只在于得到数据库的连接,并对数据库的连接做管理,不涉及到得到连接后的操 所以,spring对持久层的支持的XXXTemplate类是属于spring包下的,是spring的支持.但是数据库连接池的获取连接的数据源对象XXXDataSource对象是在第三方包内的,比如c3p0和dbcp包 3.所以不同的XXXTemplate可以和不

Spring 5.x 、Spring Boot 2.x 、Spring Cloud 与常用技术栈整合

本项目仓库提供spring.spring-boot.spring-cloud 的常用整合用例.每个用例都提供详细的图文说明,并给出官方文档的具体链接作为参考.随着spring的迭代,本仓库会持续更新,升级版本和丰富用例. 仓库地址:https://github.com/heibaiying/spring-samples-for-all 版本说明: Spring: 5.1.3.RELEASE Spring-Boot:2.1.1.RELEASE Spring-Cloud:Finchley.SR2 目

05_ssm基础(四)之Spring与持久层的整合

30.31.spring对jdbc的支持jdbcTemplate 使用Spring的JDBC准备:  1):拷贝jar:       mysql-connector-java-5.1.11.jar:MySQL驱动包       spring-jdbc-4.1.2.RELEASE.jar:支持JDBC       spring-tx-4.1.2.RELEASE.jar: 支持事务  2): 操作Product对象的DAO实现:  3):参考文档:参考Spring4.x文档的362页. 代码:如下

Spring 对持久层的支持（DAO）应用

Spring提供了模板类:     使用模板类有两种使用方式:     1.手动在dao层加上一个模板类属性       public class UserDaoImpl implements UserDao{            private  JdbcTemplate tem;//需要在配置文件中去注入该属性       } 2.让dao的实现类继承daoSupport      public class UserDaoImpl extends  JdbcDaoSupport  impl

Spring(七)持久层

一.Spring对DAO的支持 DAO:Data Access Object Spring提供了DAO框架,让开发人员无须耦合特定的数据库技术,就能进行应用程序的开发. Spring封闭了操作Oracle,MySql,DB2,SQL等数据库的用法. 它们都实现同一接口,方法也是一样的. 优势: 由于依赖于接口,可以通过依赖注入随时替换DAO接口的实现类,而应用程序完全不用了解接口与底层数据库操作细节. 应用程序----调用----->DAO接口<---实现--DAO接口实现类----操作---

SpringBoot2.0 基础案例(09)：集成JPA持久层框架，简化数据库操作

一.JAP框架简介 JPA(Java Persistence API)意即Java持久化API,是Sun官方在JDK5.0后提出的Java持久化规范.主要是为了简化持久层开发以及整合ORM技术,结束Hibernate.TopLink.JDO等ORM框架各自为营的局面.JPA是在吸收现有ORM框架的基础上发展而来,易于使用,伸缩性强. 二.与SpringBoot2.0整合 1.核心依赖 <!-- JPA框架 --> <dependency> <groupId>org.sp

第五章 征服数据库(Spring对DB的使用)——开发持久层

本章内容: 定义Spring对数据库访问的支持 配置数据库资源 使用Spring的JDBC模板 在几乎所有的企业级应用中,都需要构建数据持久层.现在意义上的数据持久层是指把对象或者数据保存到数据库中,以及从数据库中取出数据. Spring提供了一组数据访问框架,它集成了多种数据访问技术.不管是JDBC.iBATIS还是Hibernate. ? 一.Spring的数据访问哲学 Spring开发者一直坚持的一个目标之一就是:允许开发人员在开发应用软件时能够遵循面向对象原则的"针对接口编程"

基于 Spring 和 iBATIS 的动态可更新多数据源持久层

前言 我们时常会遇到一些 web 项目,需要从不同的数据源中抓取数据来进行分析,而这些数据源是有可能变化的,需要用户来进行动态的维护和添加.可是,大多数的 web 程序使用了应用服务器或者容器中间件来管理数据源的生命周期,因此数据源的变化自然不能够独立于程序,而需要由专业人士去进行维护,必要时还需要重新发布程序来适应数据源的变化,而且数据源的个数.数据库的类型也都会有所限制. 那么怎样才可以突破以上这些局限,彻底实现由用户远程对数据源进行维护和管理的需求呢?本文提出了一个有效的解决方案,该方案的

Spring Boot 入门之持久层篇（三）

原文地址:Spring Boot 入门之持久层篇(三) 博客地址:http://www.extlight.com 一.前言 上一篇<Spring Boot 入门之 Web 篇(二)>介绍了 Spring Boot 的 Web 开发相关的内容,项目的开发离不开数据,因此本篇开始介绍持久层相关的知识. 二.整合 JdbcTemplate 2.1 添加依赖 <dependency> <groupId>org.springframework.boot</groupId&g