Spring(七)持久层

一、Spring对DAO的支持

DAO:Data Access Object

Spring提供了DAO框架，让开发人员无须耦合特定的数据库技术，就能进行应用程序的开发。

Spring封闭了操作Oracle，MySql，DB2，SQL等数据库的用法。

它们都实现同一接口，方法也是一样的。

优势：

由于依赖于接口，可以通过依赖注入随时替换DAO接口的实现类，而应用程序完全不用了解接口与底层数据库操作细节。

应用程序----调用-----》DAO接口《---实现--DAO接口实现类----操作------》数据库

二、Spring注入数据源

2.1、 DataSource(数据源)

连接数据的方式称为“数据库”。比如JDBC，连接池或者JNDI

Spring通过依赖注入方式配置数据源

不同系统，数据源的管理更多是针对底层的行为，这些行为不应该影响业务。

更换数据只需修改Bean定义的内容，而不需要修改任何一行代码。

2.2、配置数据源

applicationContext.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:p="http://www.springframework.org/schema/p"
    xmlns:aop="http://www.springframework.org/schema/aop"
    xsi:schemaLocation="http://www.springframework.org/schema/beans
    http://www.springframework.org/schema/beans/spring-beans-3.1.xsd
    http://www.springframework.org/schema/aop
    http://www.springframework.org/schema/aop/spring-aop-3.1.xsd">
<!--数据源  -->
<bean id="dataSource" class="org.springframework.jdbc.datasource.DriverManagerDataSource">
<!--驱动  -->
<property name="driverClassName" value="oracle.jdbc.driver.OracleDriver"/>
<!--URL  -->
<property name="url" value="jdbc:oracl:thin:@localhost:1521:orcl"/>
<!--连接的用户名  -->
<property name="username" value="accp"></property>
<!--连接的密码  -->
<property name="password" value="accp"></property>
</bean>

</beans>

JDBC操作：

package com.pb.jdbc.dao.impl;

import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;

import javax.sql.DataSource;

import com.pb.entity.Person;
import com.pb.jdbc.dao.PersonDao;

public class PersonDaoImpl implements PersonDao {
    private DataSource dataSource;
    @Override
    public Person findById(Integer id) {
        Connection con = null;
        PreparedStatement ps = null;
        ResultSet rs = null;
        Person p=null;
        String sql="select * from person where id=?";
        Object [] params={id};
        //获取连接
        try {
            con=dataSource.getConnection();
            ps=con.prepareStatement(sql);
            if(params!=null){
            for (int i = 0; i < params.length; i++) {
                ps.setObject(i+1, params[i]);
            }
            }
            rs=ps.executeQuery();
            if(rs!=null){
                p=new Person();
                while(rs.next()){
                    p.setId(rs.getInt("id"));
                    p.setName(rs.getString("name"));
                    p.setAge(rs.getInt("age"));
                }
            }
            return p;
        } catch (SQLException e) {
            e.printStackTrace();
        }finally{

                try {
                    if(rs!=null)
                    rs.close();
                    if(ps!=null)
                        ps.close();
                    if(con!=null)
                        con.close();
                } catch (SQLException e) {
                    e.printStackTrace();
                }
        }

        return null;
    }
    public void setDataSource(DataSource dataSource) {
        this.dataSource = dataSource;
    }

}

更新applicationContext.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:p="http://www.springframework.org/schema/p"
    xmlns:aop="http://www.springframework.org/schema/aop"
    xsi:schemaLocation="http://www.springframework.org/schema/beans
    http://www.springframework.org/schema/beans/spring-beans-3.1.xsd
    http://www.springframework.org/schema/aop
    http://www.springframework.org/schema/aop/spring-aop-3.1.xsd">
<!--数据源  -->
<bean id="dataSource" class="org.springframework.jdbc.datasource.DriverManagerDataSource">
<!--驱动  -->
<property name="driverClassName" value="oracle.jdbc.driver.OracleDriver"/>
<!--URL  -->
<property name="url" value="jdbc:oracl:thin:@localhost:1521:orcl"/>
<!--连接的用户名  -->
<property name="username" value="accp"></property>
<!--连接的密码  -->
<property name="password" value="accp"></property>
</bean>
<!-- PersonDao接口实现类 -->
<bean id="personDaoImpl" class="com.pb.jdbc.dao.impl.PersonDaoImpl">
<!-- 属性关联 -->
<property name="dataSource" ref="dataSource"/>
</bean>
</beans>

三、JDBC Template

 为什么需要JDBCTemplate(JDBC模板)?

使用JDBC时，总是需要进行固定的步骤，比如Connection,Statement的获取、关闭，异常处理等。

JDBCTemplate作用：

Spring将JDBC常用的操作封装到JDBCTemplate中简化了使用JDBC的开发流程，开发人员不需要关心，获得连接和关闭连接

更改上面的代码

package com.pb.jdbc.dao.impl;

import java.math.BigDecimal;
import java.util.List;
import java.util.Map;

import javax.sql.DataSource;

import org.springframework.jdbc.core.JdbcTemplate;

import com.pb.entity.Person;
import com.pb.jdbc.dao.PersonDao;

public class JdbcTemplatePersonDaoImpl implements PersonDao {
    private JdbcTemplate jdbcTemplate;
    //根据ID查找
    @Override
    public Person findById(Integer id) {
        Person p=null;
        //返回的是集合，但集合的每个元素都是一个map
        String sql="select * from person where id=?";
        //占位符
        Object [] params={id};
        //调用SQL和占位
        List results=jdbcTemplate.queryForList(sql,params);
        for (Object object : results) {
            Map personMap=(Map) object;
            //获取每个map的值
            Long p_id=((BigDecimal) personMap.get("ID")).longValue();
            String p_name=(String) personMap.get("NAME");
            Integer p_age=((BigDecimal) personMap.get("AGE")).intValue();

            //声明
            p=new Person();
            p.setAge(p_age);
            p.setId(p_id);
            p.setName(p_name);
        }

        return p;
    }
    //通过设置数据获取JdbcTemplate的实例
    public void setDataSource(DataSource dataSource) {
        jdbcTemplate=new JdbcTemplate(dataSource);
    }

}

四、JDBC Template

要使用Jdbctemplate 对象来完成jdbc 操作。通常情况下，有三种种方式得到JdbcTemplate 对象。 

  •     第一种方式：我们可以在自己定义的DAO 实现类中注入一个DataSource 引用来完 成JdbcTemplate 的实例化。也就是它是从外部“注入” DataSource 　　到DAO 中，然后 自己实例化JdbcTemplate，然后将DataSource 设置到JdbcTemplate 对象中。 
  •       第二种方式： 在 Spring 的 IoC 容器中配置一个 JdbcTemplate 的 bean，将 DataSource 注入进来，然后再把JdbcTemplate 注入到自定义DAO 中。 
  •       第三种方式: Spring 提供了 org.springframework.jdbc.core.support.JdbcDaoSupport 类 ， 这 个 类 中 定 义 了 JdbcTemplate 属性，也定义了DataSource 属性，当设置DataSource 属性的时候，会创 建jdbcTemplate 的实例，所以我们自己编写的DAO 只需要继承JdbcDaoSupport 类， 然后注入DataSource 即可

 第一种

public class UserServiceImpl implements UserService {  

    private JdbcTemplate jdbcTemplate;  

    public JdbcTemplate getJdbcTemplate() {
        return jdbcTemplate;
    }  

                //注入方法1
    public void setJdbcTemplate(JdbcTemplate jdbcTemplate) {
        this.jdbcTemplate = jdbcTemplate;
    }  

               //其它方法这里省略……
}

application.xml   前提是已经配置了dataSource 2.2配置数据源

<bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">
        <property name = "dataSource" ref="dataSource">
</bean>
<bean id="userService" class="com.hxzy.account.jdbcTemplate.UserServiceImpl">
     <property name="jdbcTemplate" ref="jdbcTemplate"/>
</bean>

第二种 通过数据库实例化JdbcTemplate

public class UserServiceImpl implements UserService {  

        private JdbcTemplate jdbcTemplate;  

        //注入方法2
        public void setDataSource(DataSource dataSource) {
                   this.jdbcTemplate = new JdbcTemplate(dataSource);
        }  

       //其它方法省略……
}

applicationContext.xml

前提是已经配置了dataSource  2.2配置数据源

spring配置文件为：

Xml代码

<bean id="userService" class="com.hxzy.account.jdbcTemplate.UserServiceImpl">
       <property name="dataSource" ref="dataSource"/>
</bean>

第三种：

继承JdbcDaoSupport，其内部有个JdbcTemplate ，需要注入DataSource 属性来实例化。

public class UserDaoImpl extends JdbcDaoSupport implements UserDao {  

    @Override
    public void save(User user) {
        String sql = null;
        this.getJdbcTemplate().update(sql);
    }
        //其它方法省略……
}

xml

<bean id="userDao" class="com.hxzy.account.jdbcTemplate.UserDaoImpl">
           <property name="dataSource" ref="dataSource"/>
</bean>

五、JDBC Template操作数据库

 执行DDL与更新

  • 使用JdbcTemplate的execute()方法可以执行DDL语句
  • 执行update或者inert，可以使用update()方法；

package com.pb.demo;

import java.util.List;
import java.util.Map;

import javax.sql.DataSource;

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import org.springframework.jdbc.core.JdbcTemplate;
/**
 * 1.JdbcTemplate queryForXxx方法执行SQL语句
 * 2. query和update都可以使用占位符
 * 3. 返回的List中的元素为map
 * 4.使用update执行更新操作
 * 5.使用execute方法执行DDL操作
 */
public class JdbcTemplateDemo {

    public static void main(String[] args) {
        ApplicationContext context=new ClassPathXmlApplicationContext("applicationContext.xml");
        //获取数据源
        DataSource dataSource=context.getBean("dataSource",DataSource.class);
        //通过数据源实例JdbcTemplate
        JdbcTemplate jt=new JdbcTemplate(dataSource);

        //执行占位符的查询语句
        String sql_v="select * from person where name=? and age=?";
        Object [] params={"李四",24};
        //传入参数
        List result=jt.queryForList(sql_v,params);
        for (Object object : result) {
            //直接输出对象
            System.out.println(object);
            //或者输出值
            Map map=(Map)object;
            System.out.println("ID: "+map.get("ID")+"姓名："+map.get("NAME")+map.get("AGE"));
        }
        //更新
        String sql_update="update person set  name=? where age=?";
        //年龄为23的都更新为张小三
        Object [] pupdate={"张小三",23};
        //数据库受影响的行数
        int count=jt.update(sql_update, pupdate);
        System.out.println("更新了"+count+"行");
            //查询总记录数
        String sql_count="select count(*) from person";
        int totalcount=jt.queryForInt(sql_count);
        System.out.println("Person表的总记录数:  "+totalcount);
        //执行DDL语句
        //创建一张表
        String ddl="create table test(id number(4) primary key,name varchar2(50))";
        jt.execute(ddl);
        System.out.println("创建表 成功");
        //删除表
        String del_table="drop table test";
        jt.execute(del_table);
        System.out.println("删除表成功");

    }

}

配置数据如：2.2

package com.pb.demo;

import java.sql.PreparedStatement;
import java.sql.SQLException;
import java.util.ArrayList;
import java.util.List;

import javax.sql.DataSource;

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import org.springframework.jdbc.core.BatchPreparedStatementSetter;
import org.springframework.jdbc.core.JdbcTemplate;
/**
 * 使用批量处理数据
 */
public class JdbcTemplateDemo2 {

    public static void main(String[] args) {
        ApplicationContext context=new ClassPathXmlApplicationContext("applicationContext.xml");
        //获取数据源
        DataSource dataSource=context.getBean("dataSource",DataSource.class);
        //通过数据源实例JdbcTemplate
        JdbcTemplate jt=new JdbcTemplate(dataSource);

        //批量插入数据
        final int count=200;
        final List id=new ArrayList();
        final List name=new ArrayList();
        final List password=new ArrayList();
        //为集合调定值
        for (int i = 0; i < count; i++) {
            id.add(i);
            name.add("name_"+i);
            password.add("password_"+i);

        }

        //指处理数据
        String sql="insert into users values(?,?,?)";
        BatchPreparedStatementSetter bps=new BatchPreparedStatementSetter() {

            @Override
            public void setValues(PreparedStatement ps, int index) throws SQLException {
                ps.setObject(1, id.get(index));
                ps.setObject(2, name.get(index));
                ps.setObject(3, password.get(index));

            }

            @Override
            public int getBatchSize() {

                return count;
            }
        };
        //执行插入
        jt.batchUpdate(sql, bps);
        System.out.println("插入完成!");

    }

}

六、JDBC Template以对象方 式操作数据库

执行函数的类继承：

sqlfunction

package com.pb.object;

import javax.sql.DataSource;

import org.springframework.jdbc.object.SqlFunction;
/**
 * 执行函数
 *
 */
public class PersonFunction extends SqlFunction{
    public PersonFunction(DataSource ds){
        //初始化
        super(ds,"select count(*) from person");
        //编译
        compile();
    }

}

执行增加或者更新的类继承sqlupdate

package com.pb.object;

import java.sql.Types;

import javax.sql.DataSource;

import org.springframework.jdbc.object.SqlUpdate;
/**
 * 执行增加或者更新
 *
 */
public class PersonUpdate extends SqlUpdate {
    public PersonUpdate(DataSource ds){
        super(ds,"insert into person values(?,?,?)");
        //设置参数为Oracle中的数据
        int [] types={Types.BIGINT,Types.VARCHAR,Types.INTEGER};
        //设置参数
        setTypes(types);
        compile();

    }
}

执行查询的类继承MappingSqlQuery

package com.pb.object;

import java.sql.ResultSet;
import java.sql.SQLException;

import javax.sql.DataSource;

import org.springframework.jdbc.object.MappingSqlQuery;

import com.pb.entity.Person;
/**
 * 对象查询
 * @author Administrator
 *
 */
public class PersonQuery extends MappingSqlQuery {
    public PersonQuery(DataSource ds){
        super(ds,"select * from person");
        compile();
    }

    @Override
    protected Object mapRow(ResultSet rs, int rownum) throws SQLException {
        Person p=new Person();
        p.setAge(rs.getInt("age"));
        p.setId(rs.getLong("id"));
        p.setName(rs.getString("name"));

        return p;
    }

}

实现类和接口

package com.pb.dao;

import java.util.List;

import com.pb.entity.Person;

public interface PersonDao {
    //查询全部
    public List<Person> find();
    //增加
    public void update(Person p);
    //查询总记录数
    public int getCount();

}

实现类

package com.pb.dao.impl;

import java.util.List;

import javax.sql.DataSource;

import com.pb.dao.PersonDao;
import com.pb.entity.Person;
import com.pb.object.PersonFunction;
import com.pb.object.PersonQuery;
import com.pb.object.PersonUpdate;

public class ObjectPersonDaoImpl implements PersonDao {
    //3个实现类
    private PersonFunction pf=null;  //执行函数
    private PersonQuery pq=null; //执行查询
    private PersonUpdate pu=null; //执行更新

    /*
     *通过注入数据源实例化对象
     *
     */
    public void setDataSource(DataSource ds){
        pf=new PersonFunction(ds);
        pq=new PersonQuery(ds);
        pu=new PersonUpdate(ds);
    }

    @Override
    public List<Person> find() {

        return pq.execute();
    }

    @Override
    public void update(Person p) {
        //传入参数
        pu.update(p.getId(),p.getName(),p.getAge());

    }

    @Override
    public int getCount() {
        //函数使用run运行调用
        return pf.run();
    }

}

applicationContext.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:p="http://www.springframework.org/schema/p"
    xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.1.xsd">

<bean id="dataSource" class="org.springframework.jdbc.datasource.DriverManagerDataSource">
<property name="driverClassName" value="oracle.jdbc.driver.OracleDriver"/>
<property name="url" value="jdbc:oracle:thin:@localhost:1521:orcl"/>
<property name="username" value="accp"/>
<property name="password" value="accp"/>
</bean>
<bean id="objectPersonDao" class="com.pb.dao.impl.ObjectPersonDaoImpl">
<property name="dataSource" ref="dataSource"></property>
</bean>
</beans>

测试类

package com.pb.demo;

import java.util.List;

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

import com.pb.dao.PersonDao;
import com.pb.entity.Person;

public class TestObjectJdbc {

    public static void main(String[] args) {
        ApplicationContext context=new ClassPathXmlApplicationContext("applicationContext.xml");

        PersonDao opd=context.getBean("objectPersonDao",PersonDao.class);
        Person p=new Person();
        p.setAge(99);
        p.setId(7);
        p.setName("灭绝师太");

        opd.update(p);

        List<Person> persons=opd.find();

        //调用查询总记录数的方法
        System.out.println("总记录数："+opd.getCount());
        for (Person per : persons) {
            System.out.println("ID："+per.getId()+"姓名："+per.getName()+" 年龄:"+per.getAge());
        }
    }

}
时间： 2024-10-06 11:26:43

Spring(七)持久层的相关文章

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

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

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

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

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 Boot 入门之持久层篇（三）

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

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

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

SpringJdbc持久层封装，Spring jdbcTemplate封装，springJdbc泛型Dao，Spring baseDao封装

SpringJdbc持久层封装,Spring jdbcTemplate封装,springJdbc泛型Dao,Spring baseDao封装 >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> ?Copyright 蕃薯耀 2017年7月6日 http://www.cnblogs.com/fanshuy

Spring的四个基本注解annotation（控制层，业务层，持久层） @Component、@

SpringMVC中四个基本注解: @Component.@Repository   @Service.@Controller 看字面含义,很容易却别出其中三个: @Controller    控制层,就是我们的action层 @Service        业务逻辑层,就是我们的service或者manager层 @Repository  持久层,就是我们常说的DAO层 而@Component  (字面意思就是组件),它在你确定不了事哪一个层的时候使用. 其实,这四个注解的效果都是一样的,Sp

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

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

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

一.持久层技术 二.JdbcTemplate 开发步骤: 1. 导入相关的jar包 2. 配置连接池(数据源) 将参数设置到属性文件中: 3. 创建表 4. 编写实体类 5. Dao层实现 5.1 继承JdbcDaoSupport 5.2 直接注入JdbcTmplate 6. 测试 JdbcTemplate 的CRUD(待整理) 三.Hibernate 四.MyBatis 一.持久层技术 Spring 中自带的 JdbcTemplate Hibernate Mybatis 二.JdbcTempl