介绍的是Spring中的JDBC模板,Spring的连接数据库以及JDBC模板

Spring03、Spring的连年数据库以及JDBC模板,spring03jdbc

spring框架总括(04)—-介绍的是Spring中的JDBC模板,springjdbc

1.1  Jdbc模板概述

它是spring框架中提供的贰个对象,是对原始Jdbc
API对象的简便包装
。spring框架为大家提供了大多的操作模板类,入下图所示:

亚州城ca88手机版 1

大家前日的栋梁在spring-jdbc-4.24.RELEASE.jar中,我们在导包的时候,除了要导入这几个jar包外,还亟需导入多个spring-tx-4.2.4.RELEASE.jar(它是和作业相关的)。

1、Spring中的jdbc模板入门

原版的书文出自:

一、Spring对DAO的支持

 DAO:Data Access Object

Spring提供了DAO框架,让开拓职员无须耦合特定的数据库才能,就能够张开应用程序的支付。

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

它们都达成平等接口,方法也是一样的。

亚州城ca88手机版 2

优势:

由于正视于接口,能够经过信赖注入随时替换DAO接口的兑现类,而应用程序完全不用精通接口与底层数据库操作细节。

应用程序—-调用—–》DAO接口《—完毕–DAO接口完毕类—-操作——》数据库

前言

前日牵线的是有关Spring的数据库连接以及Jdbc模板的相干API方法,纵然在上学了hibernate之后,会清楚实现数据库连接一般都以运用hibernate等长久化框架来落实的。可是,比比较多时候有的提到到业务的事物使用这一个框架并不可能落实,所以我们还需求结合spring来贯彻相关的急需。

1.1.1.   创造工程、引进jar包

亚州城ca88手机版 3

 

二、Spring注入数据源

一、成立工程、导包

要想使用Spring的jdbc模板前,还供给导入相关的jar包:

亚州城ca88手机版 4

1.1.2.   创设测试表

CREATE TABLE account(

         id BIGINT PRIMARY KEY AUTO_INCREMENT,

         NAME VARCHAR(40),

         money DOUBLE

)CHARACTER SET utf8 COLLATE utf8_general_ci;

一、Spring对DAO的支持

 DAO:Data Access Object

Spring提供了DAO框架,让开辟人士无须耦合特定的数据库技能,就能够拓展应用程序的开辟。

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

它们都落到实处均等接口,方法也是毫无二致的。

亚州城ca88手机版 5

优势:

鉴于正视于接口,能够经过注重注入随时替换DAO接口的贯彻类,而应用程序完全不用通晓接口与底层数据库操作细节。

应用程序—-调用—–》DAO接口《—完成–DAO接口完毕类—-操作——》数据库

2.1、 DataSource(数据源)

总是数据的艺术叫做“数据库”。举例JDBC,连接池也许JNDI

Spring通过重视注入方式配置数据源

不相同系统,数据源的管理更加多是指向底层的一言一动,那个表现不应有影响专门的学问。

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

二、进行有关的bean的始建以及工具类的编辑撰写

1.1.3.   创设测量检验类

瞩目:需求导入c3p0的jar包

public class TestJdbcTemplate {

 

   @Test

   public void test1(){

      //创立jdbc模板对象

      JdbcTemplate jdbcTemplate = new JdbcTemplate();

      //创建c3p0数据源

      ComboPooledDataSource dataSource = new
ComboPooledDataSource();

      try {

         dataSource.setDriverClass(“com.mysql.jdbc.Driver”);

        
dataSource.setJdbcUrl(“jdbc:mysql://localhost:3306/spring_itheima10”);

         dataSource.setUser(“root”);

         dataSource.setPassword(“123456”);

      } catch亚州城ca88手机版, (PropertyVetoException e) {

         e.printStackTrace();

      }

      //设置数据源

      jdbcTemplate.setDataSource(dataSource);

      //插入操作

      jdbcTemplate.update(“insert into account(name,money)
values(?,?)”,”张三”,1000.0);

}

二、Spring注入数据源

2.2、配置数据源

亚州城ca88手机版 6

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>

 

2.1在数据库中创造了两张表,使用spring的jdbcTemplate中的API方法对这两张表张开操作

CREATE TABLE `t_dept` (
  `deptid` int(11) NOT NULL,
  `deptname` varchar(20) CHARACTER SET utf8 DEFAULT NULL,
  `remark` varchar(30) CHARACTER SET utf8 DEFAULT NULL,
  PRIMARY KEY (`deptid`)
) ENGINE=InnoDB DEFAULT CHARSET=gbk COLLATE=gbk_bin;

CREATE TABLE `user` (
  `USER_ID` int(11) NOT NULL,
  `USER_NAME` varchar(11) DEFAULT NULL,
  `USER_PASSWORD` varchar(11) DEFAULT NULL,
  `USER_ADDRESS` varchar(25) DEFAULT NULL,
  PRIMARY KEY (`USER_ID`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8;

1.1.4.   将JdbcTemplate交给Spring管理(讲某一目的大概围着提交spring进行政管理制,供给的时候一直从注明中实行田间管理是促成,收缩耦合性)

<!– 配置JdbcTemplate –>

       <bean id=“jdbcTemplate”
class=“org.springframework.jdbc.core.JdbcTemplate”>

             <property name=“dataSource”
ref=“dataSource”></property>

       </bean>

 

<!– 配置数据源 –>

       <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/spring_itheima10”></property>

          <property name=“user” value=介绍的是Spring中的JDBC模板,Spring的连接数据库以及JDBC模板。”root”></property>

          <property name=“password”
value=“123456”></property>

       </bean>

2.1、 DataSource(数据源)

连天数据的方法叫做“数据库”。比方JDBC,连接池可能JNDI

Spring通过注重注入格局地署数据源

区别体系,数据源的军管更加多是对准底层的一言一动,这么些作为不该影响专门的学业。

转移数据只需修改Bean定义的开始和结果,而不须求修改任何一行代码。

三、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);
    }

}

 

2.2开立实体bean

package com.bean;
/**
 * 创建t_dept表对应的表
 * @author 夜孤寒
 * @version 1.1.1
 *
 */
public class DeptBean {
    private int deptid;
    private String deptname;
    private String remark;
    public DeptBean() {
        super();
    }
    public DeptBean(int deptid, String deptname, String remark) {
        super();
        this.deptid = deptid;
        this.deptname = deptname;
        this.remark = remark;
    }
    public int getDeptid() {
        return deptid;
    }
    public void setDeptid(int deptid) {
        this.deptid = deptid;
    }
    public String getDeptname() {
        return deptname;
    }
    public void setDeptname(String deptname) {
        this.deptname = deptname;
    }
    public String getRemark() {
        return remark;
    }
    public void setRemark(String remark) {
        this.remark = remark;
    }
}

1.1.5.   在DAO中使用JdbcTemplate

n  创建AccountDao接口

public interface AccountDao {

   public void save(Account account);

}

n  创建AccountDaoImpl实现类

public class AccountDaoImpl  implements AccountDao {

   private JdbcTemplate jdbcTemplate;

  

   }

  

   @Override

   public void save(Account account) {

      this.jdbcTemplate.update(“insert into account(name,money)
values(?,?)”,account.getName(),account.getMoney());

   }

}

2.2、配置数据源

亚州城ca88手机版 7

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
操作。平时状态下,有三种种艺术获得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 就能够

2.3创设spring的工具类——SpringUtil.java

package com.util;

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

/**
 * 读取配置文件的工具类,实现了类似工厂模式的方式
 * 
 * @author 夜孤寒
 * @version 1.1.1
 */
public class SpringUtil {
    // 定义属性
    private static ApplicationContext context;
    // 读取配置文件
    static {
        context = new ClassPathXmlApplicationContext("spring.xml");
    }

    // 定义一个方法,判断bean是否为空,如果不为空的,获取这个bean
    public static Object getBean(String beanName) {
        // 定义一个空对象
        Object obj = null;
        // 如果beanName不为空的话,那么根据这个beanName获取到bean对象,赋值给obj并返回
        if (beanName != null && !beanName.equals("")) {
            obj = context.getBean(beanName);
        }
        return obj;
    }
}

1.1.6.   把JdbcTemplate注入给DAO(然后再通过spring把悠久层中供给的东西加多给那么些表上的是间接从spring容器中获得,不用从工作层中举办获取)

<bean id=“accountDao”
class=“cn.itcast.dao.impl.AccountDaoImpl”>

          <property name=“jdbcTemplate”
ref=“jdbcTemplate”></property>

 </bean>

 <bean id=“jdbcTemplate”
class=“org.springframework.jdbc.core.JdbcTemplate”>

          <property name=“dataSource”
ref=“dataSource”></property>

  </bean>

<bean id=“dataSource”
class=“com.mchange.v2.c3p0.ComboPooledDataSource”>

          <property name=“driverClass”
value=“com.mysql.jdbc.Driver”></property>

          <property name=“jdbcUrl”介绍的是Spring中的JDBC模板,Spring的连接数据库以及JDBC模板。
value=“jdbc:mysql://localhost:3306/spring_itheima10”></property>

          <property name=“user” value=“root”></property>

          <property name=“password”
value=“123456”></property>

   </bean>

三、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);
    }

}

 

 第一种

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>  

2.4张开布署文件的连锁配置——spring.xml文件的布局

因为要介绍的API方法大概相当多,所以三遍性将写过的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:context="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-3.0.xsd
    http://www.springframework.org/schema/context     
    http://www.springframework.org/schema/context/spring-context-3.0.xsd
    http://www.springframework.org/schema/tx 
    http://www.springframework.org/schema/tx/spring-tx-3.0.xsd
    http://www.springframework.org/schema/aop 
    http://www.springframework.org/schema/aop/spring-aop-3.0.xsd">

    <!-- 方式一:
            配置使用IOC:直接引用
     -->
     <!-- 首先需要引入一个驱动,然後到這驱动类下面,去查看他的源代码,一下是mysql需要注入的对象 -->
     <bean name="dataSource" class="org.springframework.jdbc.datasource.DriverManagerDataSource">
         <property name="driverClassName" value="com.mysql.jdbc.Driver"></property>
         <property name="url" value="jdbc:mysql://localhost:3306/spring_jdbc_test"></property>
         <property name="username" value="root"></property>
         <property name="password" value="root"></property>
     </bean>

     <!-- 使用DI注入的构造方法注入的方式来注入,并且查询我们的数据库中的数据。
              注意这里我们还需要一我们之前的dataSource作为引用
      -->
      <bean name="testMain_2" class="com.jdbc.TestMain_2">
          <property name="dataSource" ref="dataSource"></property>
      </bean>

      <!-- 使用我们的模板来获取我们的数据库中的数据 -->
      <bean name="testMain_3" class="com.jdbc.TestMain_3">
          <!-- 首先我们还是需要引入我们的数据库资源,也就是我们之前已经配置过的dataSource -->
          <property name="dataSource" ref="dataSource"></property>
      </bean>

      <!-- 方式四 -->
      <!-- 配置我们模板,然后在类就只要将这个模板用构造方法的方式注入就可以了 -->
      <bean name="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">
          <property name="dataSource" ref="dataSource"></property>
      </bean>
      <!-- 配置我们的testMain_4,然后引用我们上面配置的模板 -->
      <bean name="testMain_4" class="com.jdbc.TestMain_4">
          <property name="jdbcTemplate" ref="jdbcTemplate"></property>
      </bean>

      <!-- 方式五:
                直接继承JdbcDaoSupport这个父类,然后用里面的方法获取到模板,
                从而获取到数据。
                备注:这个是最完美的获取数据的方式,以后一般都是使用这种方式!!!
       -->
      <bean name="testMain_5" class="com.jdbc.TestMain_5">
          <property name="dataSource" ref="dataSource"></property>
      </bean>

      <!-- 使用spring配置的方式操作我们的DDL语句 -->
      <bean name="testMain_6" class="com.jdbc.TestMain_6">
          <property name="dataSource" ref="dataSource"></property>
      </bean>

      <!-- 使用spring配置的方式操作我们的DML语句 -->
      <bean name="testMain_7" class="com.jdbc.TestMain_7">
          <property name="dataSource" ref="dataSource"></property>
      </bean>

      <!-- 使用JdbcTemplate模板中的命名参数来操作我们的DML语句 -->
      <bean name="testMain_8" class="com.jdbc.TestMain_8">
          <property name="dataSource" ref="dataSource"></property> 
      </bean>

      <!-- 使用JdbcTemplate模板对于查询语句的封装 -->
      <bean name="testMain_9" class="com.jdbc.TestMain_9">
          <property name="dataSource" ref="dataSource"></property>
      </bean>

</beans>

1.1.7.   编写测验类

/**

    * 测量试验保存

    */

   @Test

   public void test2(){

      Account account = new Account();

      account.setName(“JAY”);

      account.setMoney(1000.0);

      accountDao.save(account);

   }

 

四、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 即可

第两种 通过数据库实例化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>  

2.5介绍spring对于jdbc的沙盘的支撑

(1)数据库的连日

对应xml中的配置为:

    <!-- 方式一:
            配置使用IOC:直接引用
     -->
     <!-- 首先需要引入一个驱动,然後到這驱动类下面,去查看他的源代码,一下是mysql需要注入的对象 -->
     <bean name="dataSource" class="org.springframework.jdbc.datasource.DriverManagerDataSource">
         <property name="driverClassName" value="com.mysql.jdbc.Driver"></property>
         <property name="url" value="jdbc:mysql://localhost:3306/spring_jdbc_test"></property>
         <property name="username" value="root"></property>
         <property name="password" value="root"></property>
     </bean>

相应的测量检验类:

package com.jdbc;

import java.sql.Connection;
import java.sql.SQLException;

import javax.sql.DataSource;

import com.util.SpringUtil;
/**
 * 连接数据库的测试类
 * @author 夜孤寒
 * @version 1.1.1
 *
 */
public class TestMain_1 {
    public static void main(String[] args) {
        /*
         * 本来需要用applicationContext获取到我们的bean对象,
         * 这里使用工厂类的方法将之独立出来,具体使用见SpringUtil.java
         */
        DataSource datasource=(DataSource)SpringUtil.getBean("dataSource");
        Connection conn=null;
        try{
            conn=datasource.getConnection();
        }catch(SQLException e){
            e.printStackTrace();
        }
        System.out.println(conn);//测试是否能够输出连接
    }
}

测验结果:

亚州城ca88手机版 8

同理可得测量检验成功能够获得到对应的数据库连接。

(2)测量试验从创建的user表中查询出相应的数目

对应xml配置为:

     <!-- 使用DI注入的构造方法注入的方式来注入,并且查询我们的数据库中的数据。
              注意这里我们还需要一我们之前的dataSource作为引用
      -->
      <bean name="testMain_2" class="com.jdbc.TestMain_2">
          <property name="dataSource" ref="dataSource"></property>
      </bean>

相应的测量检验类为:

package com.jdbc;

import java.sql.Connection;
import java.sql.ResultSet;

import javax.sql.DataSource;

import com.mysql.jdbc.Statement;
import com.util.SpringUtil;

/**
 * 从创建的user表中查询相关的数据
 * 
 * @author 夜孤寒
 * @version 1.1.1
 */
public class TestMain_2 {
    // 使用构造方法注入
    public DataSource datasource;

    public void setDataSource(DataSource datasource) {
        this.datasource = datasource;
    }

    /**
     *  从user表中获取所有数据
     */
    public void list() {
        /*
         * 在我们的main方法中获取到我们的datasource, 然后就能够获取连接,并且获取到数据库中的数据。
         */
        Connection conn = null;
        Statement stmt = null;
        ResultSet rs = null;
        String sql = "select * from user";
        try {
            conn = datasource.getConnection();
            stmt = (Statement) conn.createStatement();
            rs = stmt.executeQuery(sql);
            while (rs.next()) {
                System.out.println(rs.getInt("user_id") + "\t" + rs.getString("user_name") + "\t"
                        + rs.getString("user_password") + "\t" + rs.getString("user_address"));
            }
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            /*
             * 需要自己关闭资源
             */
        }
    }

    public static void main(String[] args) {
        // 获取到我们bean对象
        TestMain_2 testMain_2 = (TestMain_2) SpringUtil.getBean("testMain_2");
        // 调用我们的list方法
        testMain_2.list();
    }
}

测量检验结果:

亚州城ca88手机版 9

备考:本测验类,使用的是常用的纯粹的jdbc获取数据的艺术。

(3)使用JdbcTemplate那些类来赢获得后端的多少

相应的xml文件的布置为:

      <!-- 使用我们的模板来获取我们的数据库中的数据 -->
      <bean name="testMain_3" class="com.jdbc.TestMain_3">
          <!-- 首先我们还是需要引入我们的数据库资源,也就是我们之前已经配置过的dataSource -->
          <property name="dataSource" ref="dataSource"></property>
      </bean>

相应的测验类:

package com.jdbc;


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

import javax.sql.DataSource;

import org.springframework.jdbc.core.JdbcTemplate;

import com.util.SpringUtil;
/**
 * 使用jdbcTemplate这个类来获取后台数据
 * @author 夜孤寒
 *
 */
public class TestMain_3 {
    // 使用构造方法注入
    public DataSource datasource;

    public void setDataSource(DataSource datasource) {
        this.datasource = datasource;
    }

    public void list() {
        /*
         * 使用我们JdbcTemplate模板来获取我们的数据
         */
        JdbcTemplate jdbcTemplate=new JdbcTemplate(this.datasource);
        String sql="select * from user";
        List<Map<String, Object>>userlist=jdbcTemplate.queryForList(sql);
        for(Map<String, Object>rowMap:userlist){
            System.out.println(rowMap);
        }
    }

    public static void main(String[] args) {
        //获取到我们bean对象
        TestMain_3 testMain_3=(TestMain_3)SpringUtil.getBean("testMain_3");
        //调用我们的list方法
        testMain_3.list();
    }
}

测量试验的结果:

亚州城ca88手机版 10

这种形式的话每一遍大家都要创造贰个JdbcTemplate实例,这样子相比较复杂,所以思量能否将以此类让Spring自己创造,然后在bean配置文件中援用数据源来达到指标。这正是下面要介绍的第二种方法。

(4)在安排文件中配置大家的模板类,让Spring生成需求的bean

相应的xml配置文件为:

      <!-- 方式四 -->
      <!-- 配置我们模板,然后在类就只要将这个模板用构造方法的方式注入就可以了 -->
      <bean name="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">
          <property name="dataSource" ref="dataSource"></property>
      </bean>
      <!-- 配置我们的testMain_4,然后引用我们上面配置的模板 -->
      <bean name="testMain_4" class="com.jdbc.TestMain_4">
          <property name="jdbcTemplate" ref="jdbcTemplate"></property>
      </bean>

相应的测量试验类为:

package com.jdbc;

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

import org.springframework.jdbc.core.JdbcTemplate;

import com.util.SpringUtil;

/**
 * 在配置文件中配置模板,让spring去创建模板类
 * 
 * @author 夜孤寒
 * @version 1.1.1
 */
public class TestMain_4 {
    // 使用构造方法的方式注入template
    public JdbcTemplate jdbcTemplate;

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

    public void list() {
        /*
         * 使用我们IOC注入模板,然后引用这个使用IOC注入的模板, 最后取出我们的数据
         */
        String sql = "select USER_NAME from user";
        List<Map<String, Object>> userlist = this.jdbcTemplate.queryForList(sql);
        for (Map<String, Object> rowMap : userlist) {
            System.out.println(rowMap);
        }
    }

    public static void main(String[] args) {
        // 获取到我们bean对象
        TestMain_4 testMain_4 = (TestMain_4) SpringUtil.getBean("testMain_4");
        // 调用我们的list方法
        testMain_4.list();
    }
}

测量试验结果:

亚州城ca88手机版 11

这种措施如故需求在xml中配备,而在spring中还应该有一种特别有益于的措施正是平昔接轨JdbcDaoSupport那么些类,这种方法是最简易的,也是最常用的艺术。上边作者就归纳介绍一下这种措施的行使。

(5)承接JdbcDaoSupport类来获取数据库中的数据

对应的xml文件中的配置为:

      <!-- 方式五:
                直接继承JdbcDaoSupport这个父类,然后用里面的方法获取到模板,
                从而获取到数据。
                备注:这个是最完美的获取数据的方式,以后一般都是使用这种方式!!!
       -->
      <bean name="testMain_5" class="com.jdbc.TestMain_5">
          <property name="dataSource" ref="dataSource"></property>
      </bean>

对应的测验类为:

package com.jdbc;

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

import org.springframework.jdbc.core.support.JdbcDaoSupport;

import com.util.SpringUtil;
/**
 * 继承JdbcDaoSupport来获取模板,再通过模板来获取数据
 * @author 夜孤寒
 * @version 1.1.1
 *
 */
public class TestMain_5 extends JdbcDaoSupport {
    /*
     * 不使用DI注入的方式,直接继承一个上述的父类, 观察上述的父类,发现在这个父类里面已经实现了类似注入JdbcTemplate模板。
     */

    public void list() {
        String sql = "select * from user";
        List<Map<String, Object>> userlist = this.getJdbcTemplate().queryForList(sql);
        for (Map<String, Object> rowMap : userlist) {
            System.out.println(rowMap);
        }
    }

    public static void main(String[] args) {
        // 获取到我们bean对象
        TestMain_5 testMain_5 = (TestMain_5) SpringUtil.getBean("testMain_5");
        // 调用我们的list方法
        testMain_5.list();
    }
}

测验结果为:

亚州城ca88手机版 12

(6)使用Spring注入的方法来操作DDL语句

对应xml文件中的配置为:

      <!-- 使用spring配置的方式操作我们的DDL语句 -->
      <bean name="testMain_6" class="com.jdbc.TestMain_6">
          <property name="dataSource" ref="dataSource"></property>
      </bean>

相应的测量检验类为:

package com.jdbc;

import org.springframework.jdbc.core.support.JdbcDaoSupport;

import com.util.SpringUtil;

/**
 * 使用spring注入的方式进行DDL操作
 * 
 * @author 夜孤寒
 * @version 1.1.1
 *
 */
public class TestMain_6 extends JdbcDaoSupport {
    /*
     * 创建表
     */
    public void create() {
        StringBuffer createSQL = new StringBuffer();
        createSQL.append("create table T_Temp_XX(id int,testname varchar(30))");
        this.getJdbcTemplate().execute(createSQL.toString());
    }

    /*
     * 修改表,这里面可以添加或者删除某一个属性列
     */
    public void alter() {
        StringBuffer alterSQL = new StringBuffer();
        alterSQL.append("alter table T_Temp_XX add testpassword varchar(30)");
        this.getJdbcTemplate().execute(alterSQL.toString());
    }

    /*
     * 删除一张表
     */
    public void drop() {
        StringBuffer dropSQL = new StringBuffer();
        dropSQL.append("drop table T_Temp_XX");
        this.getJdbcTemplate().execute(dropSQL.toString());
    }

    /*
     * 测试方法
     */
    public static void main(String[] args) {
        // 获取到我们bean对象
        TestMain_6 testMain_6 = (TestMain_6) SpringUtil.getBean("testMain_6");
        // 调用我们的方法,一次调用一个方法,打开数据库观察数据库是不是已经变化了
        // testMain_6.create();
        // testMain_6.alter();
        testMain_6.drop();
    }
}

通过测验能够举办DDL操作。

(7)使用spring注入的不二诀窍打开DML操作

对应xml文件中的配置:

      <!-- 使用spring配置的方式操作我们的DML语句 -->
      <bean name="testMain_7" class="com.jdbc.TestMain_7">
          <property name="dataSource" ref="dataSource"></property>
      </bean>

对应测量试验类:

package com.jdbc;

import java.sql.PreparedStatement;
import java.sql.SQLException;

import org.springframework.jdbc.core.PreparedStatementSetter;
import org.springframework.jdbc.core.support.JdbcDaoSupport;

import com.util.SpringUtil;

/**
 * 使用spring配置的方式操作我们的DML语句
 * 
 * @author 夜孤寒
 * @version 1.1.1
 */

public class TestMain_7 extends JdbcDaoSupport {
    /*
     * statement的写法
     */
    public void insert() {
        int deptid = 1;
        String deptname = "zhangsan";
        String remark = "zhangsanzhenshuai";
        StringBuffer insertSQL = new StringBuffer();
        insertSQL.append("Insert Into T_Dept(");
        insertSQL.append("deptid,deptname");
        insertSQL.append(",remark");
        insertSQL.append(") values(");
        insertSQL.append("" + deptid + ",");
        insertSQL.append("'" + deptname + "',");
        insertSQL.append("'" + remark + "'");
        insertSQL.append("");
        insertSQL.append(")");
        int rowCount = this.getJdbcTemplate().update(insertSQL.toString());
        System.out.println("rowCount影响的行数= " + rowCount);
    }

    /*
     * prepareStatement的写法
     */
    public void update() {
        StringBuffer updateSQL = new StringBuffer();
        updateSQL.append("update t_dept set ");
        updateSQL.append("deptname = ?,");
        updateSQL.append("remark = ?");
        updateSQL.append(" where deptid=?");
        int rowCount = this.getJdbcTemplate().update(updateSQL.toString(), new PreparedStatementSetter() {
            @Override
            public void setValues(PreparedStatement ps) throws SQLException {
                ps.setString(1, "lisi");
                ps.setString(2, "lisizhenshuai");
                ps.setInt(3, 1);
            }
        });
        System.out.println("rowCount影响的行数=" + rowCount);
    }

    /*
     * prepareStatement的写法
     */
    public void delete() {
        StringBuffer deleteSQL = new StringBuffer();
        deleteSQL.append("delete from t_dept");
        deleteSQL.append(" where deptid=?");
        /*
         * 关于对象数组的使用:对象数组的第一个元素对应的是SQL语句中的第一个参数问号
         */
        Object[] obj = { 1 };
        int rowCount = this.getJdbcTemplate().update(deleteSQL.toString(), obj);
        System.out.println("rowCount影响的行数=" + rowCount);
    }

    public static void main(String[] args) {
        // 获取到bean对象
        TestMain_7 testMain_7 = (TestMain_7) SpringUtil.getBean("testMain_7");
        // 测试方法
        // testMain_7.insert();
        // testMain_7.update();
        testMain_7.delete();
    }
}

经测量试验,能够兑现DML操作中的增加和删除改查。

(8)使用JdbcTemplate模板中的命名参数来操作大家的DML语句

对应xml中的配置为:

      <!-- 使用JdbcTemplate模板中的命名参数来操作我们的DML语句 -->
      <bean name="testMain_8" class="com.jdbc.TestMain_8">
          <property name="dataSource" ref="dataSource"></property> 
      </bean>

相应的测量试验类:

package com.jdbc;

import java.util.HashMap;
import java.util.Map;

import org.springframework.jdbc.core.namedparam.BeanPropertySqlParameterSource;
import org.springframework.jdbc.core.namedparam.NamedParameterJdbcDaoSupport;
import org.springframework.jdbc.core.namedparam.NamedParameterJdbcTemplate;

import com.bean.DeptBean;
import com.util.SpringUtil;

/**
 * 使用JdbcTemplate模板中的命名参数来操作我们的DML语句
 * 
 * @author 夜孤寒
 * @version 1.1.1
 */
public class TestMain_8 extends NamedParameterJdbcDaoSupport {
    /*
     * statement的写法
     */
    public void insert(boolean flag_1, boolean flag_2) {
        int deptid = 1;
        String deptname = "zhangsan";
        String remark = "zhangsanzhenshuai";
        StringBuffer insertSQL = new StringBuffer();
        insertSQL.append("insert into T_Dept(deptid");
        if (flag_1) {
            insertSQL.append(",deptname");
        }
        if (flag_2 == true) {
            insertSQL.append(",remark");
        }
        insertSQL.append(") values(");
        insertSQL.append(":deptid");
        if (flag_1 == true) {
            insertSQL.append(",:deptname");
        }
        if (flag_2 == true) {
            insertSQL.append(",:remark");
        }
        insertSQL.append(")");
        // 将数据放进我们的map中 备注:map中key的名称==命名参数的名称
        Map<String, Object> paramMap = new HashMap<String, Object>();
        paramMap.put("deptid", deptid);
        paramMap.put("deptname", deptname);
        paramMap.put("remark", remark);
        int rowCount = this.getNamedParameterJdbcTemplate().update(insertSQL.toString(), paramMap);
        System.out.println("rowCount影响的行数= " + rowCount);
    }

    /*
     * prepareStatement的写法
     */
    public void update() {
        StringBuffer updateSQL = new StringBuffer();
        updateSQL.append("update T_Dept set");
        updateSQL.append(" deptname = :deptname,");
        updateSQL.append(" remark = :remark");
        updateSQL.append(" where deptid = :deptid");
        updateSQL.append("");
        // 获取到模板
        NamedParameterJdbcTemplate template = this.getNamedParameterJdbcTemplate();
        // 将数据放置到bean里面去
        DeptBean deptbean = new DeptBean();
        deptbean.setDeptid(1);
        deptbean.setDeptname("lisi");
        deptbean.setRemark("lisizhenshuai");
        // 使用一个bean工厂的方法将预处理我们的bean
        BeanPropertySqlParameterSource paramSource = new BeanPropertySqlParameterSource(deptbean);
        // 调用模板方法更新数据
        int rowCount = template.update(updateSQL.toString(), paramSource);
        // 输出影响的行数
        System.out.println("影响的行数rowCount=" + rowCount);
    }

    public static void main(String[] args) {
        // 获取到bean对象
        TestMain_8 testMain_8 = (TestMain_8) SpringUtil.getBean("testMain_8");
        // 测试方法
        // testMain_8.insert(true,true);//由这个参数来控制是不是插入某一个属性列的数据
        testMain_8.update();
    }
}

(9)JdbcTemplate模板对于查询语句的卷入

相应的xml文件的陈设:

      <!-- 使用JdbcTemplate模板对于查询语句的封装 -->
      <bean name="testMain_9" class="com.jdbc.TestMain_9">
          <property name="dataSource" ref="dataSource"></property>
      </bean>

相应的测量试验类:

package com.jdbc;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.List;
import java.util.Map;
import java.util.Vector;

import org.springframework.jdbc.core.BeanPropertyRowMapper;
import org.springframework.jdbc.core.ColumnMapRowMapper;
import org.springframework.jdbc.core.PreparedStatementSetter;
import org.springframework.jdbc.core.RowMapper;
import org.springframework.jdbc.core.namedparam.BeanPropertySqlParameterSource;
import org.springframework.jdbc.core.namedparam.NamedParameterJdbcTemplate;
import org.springframework.jdbc.core.support.JdbcDaoSupport;

import com.bean.DeptBean;
import com.util.SpringUtil;
/**
 * JdbcTemplate模板对于查询语句的封装测试类
 * @author 夜孤寒
 * @version 1.1.1
 */
public class TestMain_9 extends JdbcDaoSupport{
    /*
     * 最简单的一个查询
     */
    public void one(){
        System.out.println("==============================");
        System.out.println("1:返回所有的对象");
        String sql="select * from t_dept order by deptid asc";
        List<Map<String, Object>>deptList=this.getJdbcTemplate().queryForList(sql);
        for(Map<String, Object>rowMap:deptList){
            System.out.println(rowMap);
        }
        System.out.println("==============================");
        System.out.println("2:返回一条对象");
        /*
         * 返回一条对象,将返回的对象使用Map的方式来接收
         */
        sql="select * from t_dept where deptid=1";
        Map<String, Object>rowMap=this.getJdbcTemplate().queryForMap(sql);
        if(rowMap!=null){
            System.out.println(rowMap);
        }
        /*
         * 使用queryForObject方法来接收一个对象:
         *     1、如果方法的第二个参数是class类型的话,表示SQL只能返回一行一列。相当于RowMapper中的SingleColumnRowMapper;
         *     2、如果方法的第二个参数是rowMapper类型的话,表示SQL语句只能返回一行多列。
         *     一行多列,默认是返回queryForMap,但是Spring允许可以对返回的行数据进行自定义的映射
         */
        /*
         * 方式一:返回的class类型
         */
        sql="select count(1) from t_dept where deptid=1";//什么意思?
        Integer dept_count=this.getJdbcTemplate().queryForObject(sql, Integer.class);
        System.out.println("dept_count="+dept_count);
        /*
         * 方式二:返回的是rowMapper的类型
         */
        sql="select * from t_dept where deptid=1";
        BeanPropertyRowMapper<DeptBean>rowMapper=new BeanPropertyRowMapper<DeptBean>(DeptBean.class);
        //需要将返回的数据转换成bean对象
        DeptBean deptbean=this.getJdbcTemplate().queryForObject(sql, rowMapper);
        System.out.println(deptbean.getDeptid()+"\t"+deptbean.getDeptname()+"\t"+deptbean.getRemark());
        System.out.println("==============================");

    }
    /*
     * 复杂的查询queryForXX:
     * 这个是模板封装好的查询方法
     */
    @SuppressWarnings({ "unchecked", "rawtypes" })
    public void two(){
        //1、处理有预编译的语句
        String sql="select * from t_dept where deptname like ? order by deptid asc";
        List<Map<String, Object>>deptList=this.getJdbcTemplate().query(sql, new PreparedStatementSetter() {
            @Override
            public void setValues(PreparedStatement ps) throws SQLException {
                //查询带有"l"这个字符的所有对象
                ps.setString(1, "%l%");
            }
        },new ColumnMapRowMapper());//这里代表返回的是一个什么类型
        System.out.println(deptList);
        //2、处理带有预编译的语句,并且返回的是一个javabean
        List<DeptBean>deptList_2 = this.getJdbcTemplate().query(
                sql, new PreparedStatementSetter() {
                    @Override
                    public void setValues(PreparedStatement ps)
                            throws SQLException {
                        ps.setString(1, "%l%");

                    }
                }, new BeanPropertyRowMapper(DeptBean.class));
        System.out.println(deptList_2);
        //3、直接处理resultSet???????什么意思
        List<Vector<String>>deptList_3=this.getJdbcTemplate().query(sql, new PreparedStatementSetter() {

            @Override
            public void setValues(PreparedStatement ps) throws SQLException {
                ps.setString(1, "%l%");
            }
        },new RowMapper() {
            @Override
            public Object mapRow(ResultSet rs, int rowNum) throws SQLException {
                int deptid = rs.getInt("deptid");
                String deptname = rs.getString("deptname");
                Vector<String> vector = new Vector<String>();
                vector.add(String.valueOf(deptid));
                vector.add(deptname);
                return vector;
            }
        });
        System.out.println(deptList_3);
    }

    /*
     * 使用命名参数的查询:
     * 前提是首先要实例化命名参数查询的对象
     */
    public void three(){//传一个bean条件,返回结果
        //实例化一个对象
        NamedParameterJdbcTemplate template=new NamedParameterJdbcTemplate(this.getDataSource());

        //如果参数是javabean,那么返回值也就是javabean
        String sql="select * from t_dept where deptname like :deptname and remark like :remark";
        //创建一个bean,设置好查询的条件
        DeptBean parambean=new DeptBean();
        parambean.setDeptname("%l%");
        parambean.setRemark("%shuai%");
        //将创建好的bean放到查询语句的池子里面
        BeanPropertySqlParameterSource paramSource=new BeanPropertySqlParameterSource(parambean);
        BeanPropertyRowMapper<DeptBean> rowBean = new BeanPropertyRowMapper<DeptBean>(
                DeptBean.class);
        List<DeptBean>deptList=template.query(sql, paramSource, rowBean);
        for(DeptBean deptbean:deptList){
            System.out.println(deptbean.getDeptname()+"\t"+deptbean.getRemark());
        }
    }
    public static void main(String[] args) {
        //获取到bean对象
        TestMain_9 testMain_9=(TestMain_9)SpringUtil.getBean("testMain_9");
        //测试方法
//        testMain_9.one();
//        testMain_9.two();
        testMain_9.three();
    }
}

前几天作者就将Spring中的JdbcTemplate模板介绍到那。

前言
前几日介绍的是关于Spring的数据库连接以及Jdbc模板的连锁API方法,尽管在攻读了hib…

1.2. 配置DBCP连接池

 第一种

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>  

第三种:

传承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>  

 

1.2.1.   导入jar包

亚州城ca88手机版 13

第三种 通过数据库实例化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配置文件为:

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

五、JDBC Template操作数据库

 执行DDL与更新

  • 动用JdbcTemplate的execute()方法能够实行DDL语句
  • 实行update大概inert,能够利用update()方法;

亚州城ca88手机版 14

 

亚州城ca88手机版 15

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

亚州城ca88手机版 16

 

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("插入完成!");

    }

}

1.2.2.   配置DBCP连接池

<!– 配置dbcp数据库源 –>

       <bean id=“dataSource”
class=“org.apache.commons.dbcp.BasicDataSource”>

             <property name=“driverClassName”
value=“com.mysql.jdbc.Driver”></property>

             <property name=“url”
value=“jdbc:mysql://localhost:3306/spring”></property>

             <property name=“username”
value=“root”></property>

             <property name=“password”
value=“123456”></property>

       </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以指标方 式操作数据库

亚州城ca88手机版 17

亚州城ca88手机版 18

亚州城ca88手机版 19

亚州城ca88手机版 20

试行函数的类承接:

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

}

 

1.3. 铺排Spring自带的数据库连接池

 <!– 配置spring自带的数量源 –>

 

        <bean id=“dataSource”
class=“org.springframework.jdbc.datasource.DriverManagerDataSource”>

          <property name=“driverClassName”
value=“com.mysql.jdbc.Driver”></property>

          <property name=“url”
value=“jdbc:mysql://localhost:3306/spring_itheima10”></property>

          <property name=“username”
value=“root”></property>

          <property name=“password”
value=“123456”></property>

       </bean>

 

总结:

三种格局:一种是c3p0数据源举行陈设,一种是dbcp数据源举办安插,第二种Spring自带的数据源实行布局达成那些进程中的数据。

 

五、JDBC Template操作数据库

 执行DDL与更新

  • 利用JdbcTemplate的execute()方法可以推行DDL语句
  • 实践update大概insert,能够动用update()方法;

亚州城ca88手机版 21

 

亚州城ca88手机版 22

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

亚州城ca88手机版 23

 

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("插入完成!");

    }

}

1.4. 将数据库连接信息保存到属性文件中

六、JDBC Template以指标方 式操作数据库

亚州城ca88手机版 24

亚州城ca88手机版 25

亚州城ca88手机版 26

亚州城ca88手机版 27

执行函数的类承继:

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

}

1.4.1.   新建jdbc.properties属性文件

亚州城ca88手机版 28

 

jdbc.driverClass=com.mysql.jdbc.Driver

jdbc.url=jdbc:mysql://localhost:3306/hibernate_itcast55

jdbc.username=root

jdbc.password=123456

 

1.4.2.   在applicationContext.xml中引入jdbc.properties文件

n  配置bean引入

      <!– 配置bean引入jdbc.properties –>

       <bean
class=“org.springframework.beans.factory.config.PropertyPlaceholderConfigurer”>

             <property name=“location”
value=“classpath:jdbc.properties”></property>

       </bean>

       

       <!– 配置数据源 –>

       <bean id=“dataSource”
class=“org.springframework.jdbc.datasource.DriverManagerDataSource”>

             <property name=“driverClassName”
value=“${driverClass}”></property>

             <property name=“url”
value=“${jdbcUrl}”></property>

             <property name=“username”
value=“${user}”></property>

             <property name=“password”
value=“${password}”></property>

       </bean>

n  通过context标签引进

 <!– 通过context标签引入jdbc.properties –>

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

提醒:此处不加classpath也行,因为jdbc.properties就位于类路线下,就坐落类一般加上。

 

总结:引进jdbc.properties配置文件的两种方法:1、使用布置bean进行引进(第一种艺术)

                                                                     
              2、通过context情势张开引进

 

1.5. 应用Jdbc模板落成CRUD

 

1.5.1.   新添多少

/**

    * JdbcTemplate之新增

    */

   @Test

   public void test1(){

      jdbcTemplate.update(“insert into account(name,money)
values(?,?)”,”李四”,1000);

   }

 

1.5.2.   修改数据

/**

    * JdbcTemplate之修改

    */

   @Test

   public void test2(){

      jdbcTemplate.update(“update account set money = ? where id =
?”,1100,1);

   }

1.5.3.   删除数据

/**

    * JdbcTemplate之删除

    */

   @Test

   public void test3(){

      jdbcTemplate.update(“delete from account where id = ?”,2);

   }

 查询数据相比较简单此处省略

 

1.1.1.1.        查询某列的值

/**

    * JdbcTemplate之查询某列的值

    */

   @Test

   public void test5(){

      double money = jdbcTemplate.queryForObject(“select money from
account where id = ?”, Double.class, 1);

      System.out.println(money);

   }

1.1.1.1.        查询贰个目的

n  创设实体类

public class Account implements Serializable{

 

   private static final long serialVersionUID =
1L;

   private Long id;

   private String name;

   private Double money;

   public Long getId() {

      return id;

   }

   public void setId(Long id) {

      this.id = id;

   }

   public String getName() {

      return name;

   }

   public void setName(String name) {

      this.name = name;

   }

   public Double getMoney() {

      return money;

   }

   public void setMoney(Double money) {

      this.money = money;

   }

   @Override

   public String toString() {

      return “Account [id=” + id + “, name=” + name + “, money=” +
money + “]”;

   }

}

n  创建RowMapper

public class AccountRowMapper implements
RowMapper<Account>{

 

   @Override

   public Account mapRow(ResultSet rs, int rownum) throws
SQLException {

      Account account = new Account();

      account.setId(rs.getInt(“id”));

      account.setName(rs.getString(“name”));

      account.setMoney(rs.getDouble(“money”));

      return account;

   }

 

}

n  查询获得叁个对象

/**

    * JdbcTemplate之查询三个对象

    */

   @Test

   public void test4(){

      AccountRowMapper mapper = new AccountRowMapper();

      Account account = jdbcTemplate.queryForObject(“select * from
account where id = ?”, mapper, 1);

      System.out.println(account);

   }

1.1.1.2.        查询一个集中

/**

    * JdbcTemplate之查询贰个聚众

    */

   @Test

   public void test6(){

      AccountRowMapper rowMapper = new AccountRowMapper();

      List<Account> accounts = jdbcTemplate.query(“select * from
account”, rowMapper);

      for(int i = 0;i < accounts.size();i++){

         System.out.println(accounts.get(i));

      }

   }

 

1.6. 在DAO中使用JdbcTemplate的二种格局

1.6.1.   格局一:在DAO中中央银行政机关接流入JdbcTemplate

 编写DAO,注入JdbcTemplate

public class AccountDaoImpl implements AccountDao {

  

   private JdbcTemplate jdbcTemplate;

  

   public void setJdbcTemplate(JdbcTemplate jdbcTemplate) {

      this.jdbcTemplate = jdbcTemplate;

   }

 

   @Override

   public void save(Account account) {

      jdbcTemplate.update(“insert into account(name,money) values(?,?)”,
account.getName(),account.getMoney());

   }

 

}

   把DAO配置到Spring中

  <bean id=“accountDao”
class=“cn.itcast.dao.impl.AccountDaoImpl”>

         <property name=“jdbcTemplate”
ref=“jdbcTemplate”></property>

  </bean>

 

1.6.2.   方式二:在DAO中使用JdbcDaoSupport

 让DAO继承JdbcDaoSupport

public class AccountDaoImpl extends JdbcDaoSupport
implements AccountDao {

  

   @Override

   public void save(Account account) {

      this.getJdbcTemplate().update(“insert into account(name,money)
values(?,?)”, account.getName(),account.getMoney());

   }

 

}

  给DAO注入DataSource

<bean id=“accountDao”
class=“cn.itcast.dao.impl.AccountDaoImpl”>

       <property name=“dataSource”
ref=“dataSource”></property>

</bean>

 

比较:两版Dao有如何界别吧?

先是种在Dao类中定义JdbcTemplate的方法,适用于具备配置格局(xml和注释都得以)。

其次种让Dao承接JdbcDaoSupport的诀窍,只可以用于基于XML的法门,申明用持续。

三种dao类中定义jdbcTemplate的不二等秘书诀,适用于具备的布署格局,(xml和注释都是足以应用的一种艺术)

 

2、第二大块内容介绍———————————————-Spring中的事务调控**

事情的想起:

l  事务的定义


事务是逻辑上一组操作,组成那组操作各种逻辑单元,要么一齐成功,要么一同失利。

l  事务的特征

n  原子性

n  一致性

n  隔离性

n  持久性

l  若是不思虑隔绝性,引发安全难点

n  读问题

u  脏读

u  不可重复读

u  虚读

n  写问题

u  错过更新

l  化解读难点

n  设置工作隔断等第

u  read uncommitted

read committed

repeatable read

u  Serializable

1.1 Jdbc模板概述 它是spring框架中提供的贰个指标, 是对原有 Jdbc API
对象的轻易…

Post Author: admin

发表评论

电子邮件地址不会被公开。 必填项已用*标注