zoukankan html css js c++ java

（二）Spring框架之JDBC的基本使用（p6spy插件的使用）

案例一：用Spring IOC方式使用JDBC

Test_2.java

package jdbc;

import java.lang.Thread.State;
import java.sql.Connection;
import java.sql.Statement;

import javax.sql.DataSource;

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

/**
 * 本类中的数据源dataSource成员属性是通过IOC方式注入，
 * @author 半颗柠檬、
 *
 */
public class Test_2 {
    private DataSource dataSource;

    public void setDataSource(DataSource dataSource) {
        this.dataSource = dataSource;
    }
    
    
    public void addUser() throws Exception{
        
        String sql="insert into user value('111',15,'男')";
        System.out.println(this.dataSource);
        Connection conn=null;
        Statement stat=null;
        try {
            conn=this.dataSource.getConnection();    
            System.out.println("conn="+conn);
            stat=conn.createStatement();
            stat.executeUpdate(sql);

            
        } catch (Exception e) {
            e.printStackTrace();
        }finally{    
//            conn.close();
//            stat.close();
        } 
    }
    
    public static void main(String[] args) throws Exception {
        /*
         * 这里不能用Test_2 test_2=new Test_2() 这种方法来获得Test_2对象，否则spring.xml里把DataSource注入到Test_2的成员变量dataSource将无效。
         */
        ApplicationContext context=new ClassPathXmlApplicationContext("spring.xml");
        Test_2 test_2=(Test_2)context.getBean("test_2");
        test_2.addUser();
        
        
    }

}

　　spring.xml

<bean id="dateSource" class="org.springframework.jdbc.datasource.DriverManagerDataSource">
        <!-- 推荐使用配置文件的方法来设置数据源的参数-->
        
        <constructor-arg index="0" name="driverClassName" value="com.mysql.jdbc.Driver"></constructor-arg>
        <!-- xml文件中不能直接用&号，要用"&amp;"取代，否则报错，如下 -->
        <constructor-arg index="1" value="jdbc:mysql://127.0.0.1:3306/user?useUnicode=true&amp;characterEncoding=UTF-8"></constructor-arg>
        <constructor-arg index="2" name="username" value="root"></constructor-arg>
        <constructor-arg index="3" name="password" value=""></constructor-arg>
    </bean>
    
    <!-- test_2类中需要的配置 -->
    <bean id="test_2" class="jdbc.Test_2">
        <property name="dataSource"  ref="dateSource"></property>
    </bean>
    <!-- end -->

其中org.springframework.jdbc.datasource.DriverManagerDataSource 类是用来设置数据源的。

结果：

　　案例二：使用JdbcTemplate模版来使用jdbc。
- JdbcTemplate对数据库的操作在jdbc上面做了深层次的封装。

　　Test_3.java

package jdbc;

import javax.sql.DataSource;

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import org.springframework.jdbc.core.JdbcTemplate;

/**
 * Spring对数据库的操作在jdbc上面做了深层次的封装，
 * 使用spring的注入功能，可以把DataSource注册到JdbcTemplate之中。
 * @author Administrator
 *
 */
public class Test_3 {

    private DataSource dataSouce;
    
    public void setDataSouce(DataSource dataSouce) {
        this.dataSouce = dataSouce;
    }

    public void addUser(){
        String sql="insert into user value('222',15,'男')";
        
        JdbcTemplate jdbcTemplate=new JdbcTemplate(this.dataSouce);
        
        jdbcTemplate.execute(sql);
        
    }

    public static void main(String[] args) {
        ApplicationContext context=new ClassPathXmlApplicationContext("spring.xml");
        Test_3 test_3=(Test_3)context.getBean("test_3");
        
        test_3.addUser();
            
    }
    
}

　　spring.xml

<bean id="dateSource" class="org.springframework.jdbc.datasource.DriverManagerDataSource">
        <!-- 推荐使用配置文件的方法来设置数据源的参数-->
        
        <constructor-arg index="0" name="driverClassName" value="com.mysql.jdbc.Driver"></constructor-arg>
        <!-- xml文件中不能直接用&号，要用"&amp;"取代，否则报错，如下 -->
        <constructor-arg index="1" value="jdbc:mysql://127.0.0.1:3306/user?useUnicode=true&amp;characterEncoding=UTF-8"></constructor-arg>
        <constructor-arg index="2" name="username" value="root"></constructor-arg>
        <constructor-arg index="3" name="password" value=""></constructor-arg>
    </bean>

    
    <!-- test_3类中需要的配置 -->
    <bean id="test_3" class="jdbc.Test_3">
        <property name="dataSouce" ref="dateSource"></property>
    </bean>
    <!-- end-->

结果：

　　案例三：将JdbcTemplate作为成员属性，直接在类中使用。

Test_4.java

package jdbc;

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import org.springframework.jdbc.core.JdbcTemplate;

/**
 * pring.xml中将jdbctemplate模版注入到本类中，
 * jdbctemplate模版中又需要注入一个数据源的对象。
 * @author Administrator
 *
 */
public class Test_4 {
        
    private JdbcTemplate jdbctemplate;

    public void setJdbctemplate(JdbcTemplate jdbctemplate) {
        this.jdbctemplate = jdbctemplate;
    }
      
    public void addUser(){
        String sql="insert into user value('333',15,'男')";
        this.jdbctemplate.execute(sql);
    }
    
        public static void main(String[] args) {
            
            ApplicationContext context=new ClassPathXmlApplicationContext("spring.xml");
            Test_4 test_4=(Test_4)context.getBean("test_4");
            test_4.addUser();
            
        }
            
}

　　spring.xml

    <bean id="dateSource" class="org.springframework.jdbc.datasource.DriverManagerDataSource">
        <!-- 推荐使用配置文件的方法来设置数据源的参数-->
        
        <constructor-arg index="0" name="driverClassName" value="com.mysql.jdbc.Driver"></constructor-arg>
        <!-- xml文件中不能直接用&号，要用"&amp;"取代，否则报错，如下 -->
        <constructor-arg index="1" value="jdbc:mysql://127.0.0.1:3306/user?useUnicode=true&amp;characterEncoding=UTF-8"></constructor-arg>
        <constructor-arg index="2" name="username" value="root"></constructor-arg>
        <constructor-arg index="3" name="password" value=""></constructor-arg>
    </bean>

        <!-- test_4类中需要的配置 -->
    <bean id="jdbctemplate" class="org.springframework.jdbc.core.JdbcTemplate">
        <property name="dataSource" ref="dateSource"></property>
    </bean>
    
    <bean id="test_4" class="jdbc.Test_4">
        <property name="jdbctemplate" ref="jdbctemplate"></property>
    </bean>
    <!-- end -->

结果：

　　案例四：使用JdbcDaoSupport包来使用spring JDBC

Test_5.java

package jdbc;

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import org.springframework.jdbc.core.support.JdbcDaoSupport;

/**
 * 使用JdbcDaoSupport包来使用spring JDBC
 * JdbcDaoSupport是JDBC数据访问对象的超类。它与特定的数据源相关联。这个类最重要的功能就是使子类可以使用JdbcTemplate对象。 
 * @author 半颗柠檬、
 *
 */
public class Test_5  extends JdbcDaoSupport{
    
    private void addUser(){
        String sql="insert into user value('555',15,'男')";
        this.getJdbcTemplate().execute(sql);
    }
    
    
    public static void main(String[] args) {
        ApplicationContext context=new ClassPathXmlApplicationContext("spring.xml");

        Test_5 test_5=(Test_5)context.getBean("test_5");
        test_5.addUser();
    }

}

spring.xml

     <bean id="dateSource" class="org.springframework.jdbc.datasource.DriverManagerDataSource">
        <!-- 推荐使用配置文件的方法来设置数据源的参数-->
        
        <constructor-arg index="0" name="driverClassName" value="com.mysql.jdbc.Driver"></constructor-arg>
        <!-- xml文件中不能直接用&号，要用"&amp;"取代，否则报错，如下 -->
        <constructor-arg index="1" value="jdbc:mysql://127.0.0.1:3306/user?useUnicode=true&amp;characterEncoding=UTF-8"></constructor-arg>
        <constructor-arg index="2" name="username" value="root"></constructor-arg>
        <constructor-arg index="3" name="password" value=""></constructor-arg>
    </bean>

       <!-- test_5类中需要的配置 -->
    <bean id="jdbctemplate" class="org.springframework.jdbc.core.JdbcTemplate">
        <property name="dataSource" ref="dateSource"></property>
    </bean>

    <!-- test_5类中需要的配置 -->
    <bean id="test_5" class="jdbc.Test_5" >
        <property name="jdbcTemplate" ref="jdbctemplate">
        </property>
    </bean>

结果：

案例五： spring jdbc 进行DML（DML 数据操作语言 (insert/update/delete 等语句)）

Test_DML.java

package jdbc;

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import org.springframework.jdbc.core.support.JdbcDaoSupport;

/**
 * DML 数据操作语言 (insert/update/delete 等语句)。
 * 
 * @author 半颗柠檬、
 *
 */
public class Test_DML extends JdbcDaoSupport{
    /**
     * insert语句
     */
    private void insert(){
        String sql="insert into  user values('666',15,'女')";
        this.getJdbcTemplate().execute(sql);
    }
    
    /**
     *更新语句 
     */
    private void update() {
        String sql="update  user set sex='男' where userName='111'";
        this.getJdbcTemplate().execute(sql);
    }
    
    /**
     * 删除语句
     */
    private void delete() {
    
        String sql="delete from user where userName='111'";
        this.getJdbcTemplate().execute(sql);
        
    }

    public static void main(String[] args) {
        
        ApplicationContext context=new ClassPathXmlApplicationContext("spring.xml");
        Test_DML test_DML=(Test_DML) context.getBean("test_DML");
        
        test_DML.insert();
    //    test_DML.update();
    //    test_DML.delete();
        
    }
}

　　spring.xml

    <bean id="dateSource" class="org.springframework.jdbc.datasource.DriverManagerDataSource">
        <!-- 推荐使用配置文件的方法来设置数据源的参数-->
        
        <constructor-arg index="0" name="driverClassName" value="com.mysql.jdbc.Driver"></constructor-arg>
        <!-- xml文件中不能直接用&号，要用"&amp;"取代，否则报错，如下 -->
        <constructor-arg index="1" value="jdbc:mysql://127.0.0.1:3306/user?useUnicode=true&amp;characterEncoding=UTF-8"></constructor-arg>
        <constructor-arg index="2" name="username" value="root"></constructor-arg>
        <constructor-arg index="3" name="password" value=""></constructor-arg>
    </bean>
    
    
    <bean id="jdbctemplate" class="org.springframework.jdbc.core.JdbcTemplate">
        <property name="dataSource" ref="dateSource"></property>
    </bean>
    
  
    <!-- test_DML类中需要的配置 -->
    <bean id="test_DML" class="jdbc.Test_DML" >
        <property name="jdbcTemplate" ref="jdbctemplate">
        </property>
    </bean>
    <!-- end -->

结果：

案例六： spring jdbc 进行DDL（DDL 数据定义语言(create/drop/alter)）

Test_DDL.java

package jdbc;

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import org.springframework.jdbc.core.support.JdbcDaoSupport;
/**
 * DDL 数据定义语言(create/drop/alter)
 * @author 半颗柠檬、
 *
 */
public class Test_DDL  extends JdbcDaoSupport{
    /*
     *create语句
     */
    private void create() {
        String sql="create table abc (name int)";
        this.getJdbcTemplate().execute(sql);

    }
    /*
     * drop语句
     */
    private void drop() {
        String sql="drop table abc";
        this.getJdbcTemplate().execute(sql);

    }
    /*
     * alter语句
     */
    private void alter() {
        String sql="alter table abc add birthday date";
        this.getJdbcTemplate().execute(sql);
    }
    
    public static void main(String[] args) {
        
        ApplicationContext context=new ClassPathXmlApplicationContext("spring.xml");
        Test_DDL test_DDL=(Test_DDL)context.getBean("test_DDL");
  　　    test_DDL.create();  
    //    test_DDL.drop();
    //    test_DDL.alter();
        
    }
}

　　spring.xml

    
<bean id="dateSource" class="org.springframework.jdbc.datasource.DriverManagerDataSource">
        <!-- 推荐使用配置文件的方法来设置数据源的参数-->
        
        <constructor-arg index="0" name="driverClassName" value="com.mysql.jdbc.Driver"></constructor-arg>
        <!-- xml文件中不能直接用&号，要用"&amp;"取代，否则报错，如下 -->
        <constructor-arg index="1" value="jdbc:mysql://127.0.0.1:3306/user?useUnicode=true&amp;characterEncoding=UTF-8"></constructor-arg>
        <constructor-arg index="2" name="username" value="root"></constructor-arg>
        <constructor-arg index="3" name="password" value=""></constructor-arg>
    </bean>

    <bean id="jdbctemplate" class="org.springframework.jdbc.core.JdbcTemplate">
        <property name="dataSource" ref="dateSource"></property>
    </bean>

        <!-- test_DDL类中需要的配置 -->
        <bean id="test_DDL" class="jdbc.Test_DDL">
            <property name="jdbcTemplate" ref="jdbctemplate"></property>
        </bean>
    <!-- end -->

结果：

案例七：spring JDBC 使用预处理语句

Test_prepared.java

package jdbc;

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

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import org.springframework.jdbc.core.PreparedStatementCallback;
import org.springframework.jdbc.core.PreparedStatementCreator;
import org.springframework.jdbc.core.PreparedStatementSetter;
import org.springframework.jdbc.core.support.JdbcDaoSupport;

/**
 * spring JDBC 的预编译语句
 *  本类中有三种方式来处理预编译语句
 * @author 半颗柠檬、
 *
 */

public class Test_prepared extends JdbcDaoSupport {

    private void prepared_1() {

        String sql = "update user set age=?,sex=? where userName=?";

        this.getJdbcTemplate().update(sql, new PreparedStatementSetter() {

            public void setValues(PreparedStatement ps) throws SQLException {
                ps.setInt(1, 105);
                ps.setString(2, "女");
                ps.setString(3, "张三");

            }

        });

    }

    private void prepared_2() {
        final String sql = "update user set age=?,sex=? where userName=?";
        this.getJdbcTemplate().update(new PreparedStatementCreator() {

            public PreparedStatement createPreparedStatement(Connection con) throws SQLException {
                PreparedStatement pstat = con.prepareStatement(sql);

                pstat.setInt(1, 1);
                pstat.setString(2, "NONE");
                pstat.setString(3, "张三");

                return pstat;
            }
        });

    }

    private void prepared_3() {
        String sql = "update user set age=?,sex=? where userName=?";
        Object[] obj={500,"女","张三"};
        this.getJdbcTemplate().update(sql,obj);

    }

    public static void main(String[] args) {

        ApplicationContext context = new ClassPathXmlApplicationContext("spring.xml");
        Test_prepared test_prepared = (Test_prepared) context.getBean("test_prepared");
    //    test_prepared.prepared_1();
    //    test_prepared.prepared_2();
        test_prepared.prepared_3();
    
    }
}

spring.xml

<bean id="dateSource" class="org.springframework.jdbc.datasource.DriverManagerDataSource">
        <!-- 推荐使用配置文件的方法来设置数据源的参数-->
        
        <constructor-arg index="0" name="driverClassName" value="com.mysql.jdbc.Driver"></constructor-arg>
        <!-- xml文件中不能直接用&号，要用"&amp;"取代，否则报错，如下 -->
        <constructor-arg index="1" value="jdbc:mysql://127.0.0.1:3306/user?useUnicode=true&amp;characterEncoding=UTF-8"></constructor-arg>
        <constructor-arg index="2" name="username" value="root"></constructor-arg>
        <constructor-arg index="3" name="password" value=""></constructor-arg>
    </bean>

    <bean id="jdbctemplate" class="org.springframework.jdbc.core.JdbcTemplate">
        <property name="dataSource" ref="dateSource"></property>
    </bean>

  <!-- test_prepared类中需要的配置 -->
        <bean id="test_prepared" class="jdbc.Test_prepared">
            <property name="jdbcTemplate" ref="jdbctemplate"></property>
        </bean>
    <!-- end -->

结果：

案例九：具名参数模版类NamedParameterJdbcTemplate来处理预编译语句，解决动态生成的预编译语句下标不好处理的问题。

Test_Prepared_Name.java

package jdbc;

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

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import org.springframework.jdbc.core.namedparam.BeanPropertySqlParameterSource;
import org.springframework.jdbc.core.namedparam.MapSqlParameterSource;
import org.springframework.jdbc.core.namedparam.NamedParameterJdbcTemplate;
import org.springframework.jdbc.core.namedparam.SqlParameterSource;
import org.springframework.jdbc.core.support.JdbcDaoSupport;

import bean.UserBean;

/**
 * 用具名参数模版类NamedParameterJdbcTemplate来处理预编译语句。 主要解决：在经典的 JDBC 用法中, SQL 参数是用占位符 ?
 * 表示,并且受到位置的限制. 定位参数的问题在于, 一旦参数的顺序发生变化, 就必须改变参数绑定.SQL语句是通过动态拼凑产生的，下标索引不好确定。
 * 本类中使用三种方法来解决上述问题
 * 
 * @author 半颗柠檬、
 *
 */
public class Test_Prepared_Name extends JdbcDaoSupport {

    /**
     * NamedParameterJdbcTemplate，update(String sql,Map<String,?> map) 
     * @param sex
     * @param age
     * @param userName
     */
    private void prepared_name_1(String sex, int age, String userName) {

        Map<String, Object> paramMap = new HashMap<String, Object>();

        paramMap.put("sex", sex);
        paramMap.put("userName", userName);
        paramMap.put("age", age);

        String sql = "update  user set userName=userName";
        if (sex != null && !sex.equals("")) {
            sql = sql + ", sex=:sex ";

        }
        if (age != 0) {

            sql = sql + ",age=:age";

        }
        if (userName != null && !userName.equals("")) {

            sql = sql + " where userName=:userName";
        }

        NamedParameterJdbcTemplate template = new NamedParameterJdbcTemplate(this.getDataSource());
        template.update(sql, paramMap); 

    }

    
    /**
     * NamedParameterJdbcTemplate，update(String sql,MapSqlParameterSource paramMap) 
     * @param sex
     * @param age
     * @param userName
     */
    private void prepared_name_2(String sex, int age, String userName) {

        MapSqlParameterSource paramMap = new MapSqlParameterSource();

        paramMap.addValue("sex", sex);
        paramMap.addValue("age", age);
        paramMap.addValue("userName", userName);

        String sql = "update  user set userName=userName";
        if (sex != null && !sex.equals("")) {
            sql = sql + ", sex=:sex ";

        }
        if (age != 0) {

            sql = sql + ",age=:age";

        }
        if (userName != null && !userName.equals("")) {

            sql = sql + " where userName=:userName";
        }

        NamedParameterJdbcTemplate template = new NamedParameterJdbcTemplate(this.getDataSource());
        template.update(sql, paramMap);
    }

    /**
     * NamedParameterJdbcTemplate，update(String sql,BeanPropertySqlParameterSource paramMap) 
     * @param userbean
     */
    private void prepared_name_3(UserBean userbean) {
        BeanPropertySqlParameterSource paramMap = new BeanPropertySqlParameterSource(userbean);

        String sql = "update  user set userName=userName";
        if (userbean.getSex() != null && !userbean.getSex().equals("")) {
            sql = sql + ", sex=:sex ";

        }
        if (userbean.getAge() != 0) {

            sql = sql + ",age=:age";

        }
        if (userbean.getUserName() != null && !userbean.getUserName().equals("")) {

            sql = sql + " where userName=:userName";
        }

        NamedParameterJdbcTemplate template = new NamedParameterJdbcTemplate(this.getDataSource());
        template.update(sql, paramMap);
    }

    public static void main(String[] args) {

        ApplicationContext context = new ClassPathXmlApplicationContext("spring.xml");
        Test_Prepared_Name test_Prepared_Name = (Test_Prepared_Name) context.getBean("test_prepared_name");
        // test_Prepared_Name.prepared_name_1(null, 155, "杨千嬅");

        // test_Prepared_Name.prepared_name_2("未知", 108, "杨千嬅");
        UserBean userbean = new UserBean("杨千嬅", 1211, "女1");
        test_Prepared_Name.prepared_name_3(userbean);

    }

}

spring.xml

<bean id="dateSource" class="org.springframework.jdbc.datasource.DriverManagerDataSource">
        <!-- 推荐使用配置文件的方法来设置数据源的参数-->
        
        <constructor-arg index="0" name="driverClassName" value="com.mysql.jdbc.Driver"></constructor-arg>
        <!-- xml文件中不能直接用&号，要用"&amp;"取代，否则报错，如下 -->
        <constructor-arg index="1" value="jdbc:mysql://127.0.0.1:3306/user?useUnicode=true&amp;characterEncoding=UTF-8"></constructor-arg>
        <constructor-arg index="2" name="username" value="root"></constructor-arg>
        <constructor-arg index="3" name="password" value=""></constructor-arg>
    </bean>

    <bean id="jdbctemplate" class="org.springframework.jdbc.core.JdbcTemplate">
        <property name="dataSource" ref="dateSource"></property>
    </bean>

<!-- test_prepared类中需要的配置 -->
        <bean id="test_prepared_name" class="jdbc.Test_Prepared_Name">
            <property name="jdbcTemplate" ref="jdbctemplate"></property>
        </bean>
        
    <!-- end -->

结果：

案例八：spring JDBC 的几种查询操作，并返回各种类型的结果集。

Test_Query.java

package jdbc;

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

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import org.springframework.jdbc.core.BeanPropertyRowMapper;
import org.springframework.jdbc.core.JdbcTemplate;
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.namedparam.SqlParameterSource;
import org.springframework.jdbc.core.support.JdbcDaoSupport;

import bean.UserBean;
/**
 * spring JDBC 的几种查询操作，并返回各种类型的结果集
 * @author 半颗柠檬、
 *
 */
public class Test_Query extends JdbcDaoSupport{

    /*
     * 把查询结果为多行数据封装为一个List，List中每个对象为一个Map，Map中存放着数据库中每行的数据(以列名=值的形式)
     */
    private void queryForList() {
        String sql="select * from user";
    List<Map<String,Object>> listMap=    this.getJdbcTemplate().queryForList(sql);

        for(Map<String, Object> map:listMap){
            
            System.out.println(map);
        }
    
    
    }
    
    /*
     * 把查询结果为单行数据封装为一个Map。
     */
    private void queryForMap() {
     String sql="select * from user where userName='李四'";
     
     Map<String,Object> map=this.getJdbcTemplate().queryForMap(sql);
     
     System.out.println(map);

    }
    
    /**
     * 把查询结果为单行（多行）数据封装为自定义Object类型
     */
    private void queryForObject() {
        /**
         * 查询某个表中共有多少条数据,queryForObject(sql, requiredType) 中的requiredType只能为基本类型或者String类型（也不能是这些类型的数组），
         * 否则报错，查询的结果也只能是查询某个表中某一列的数据且只能是一条数据，
         */
        String sql="select count(1) from user";
        Long rsCount=    this.getJdbcTemplate().queryForObject(sql, Long.class);
        
        System.out.println(rsCount);
        

    }
    
    private void queryForBean() {
        /**
         *  将结果封装为一个List<bean >
         *  sping中的RowMapper可以将数据中的每一行数据封装成用户定义的类
         */
        String sql="select * from user";
      
        BeanPropertyRowMapper<UserBean> mapper=new BeanPropertyRowMapper<UserBean>(UserBean.class);
        List<UserBean> userList=this.getJdbcTemplate().query(sql, mapper);
        
        for(UserBean user:userList){
            System.out.println(user.getUserName());
        }
        
        /**
         * 将结果封装为单个Bean
         */
    
        sql="select * from user where userName='杨千嬅'";
        BeanPropertyRowMapper<UserBean> rowMapper=new BeanPropertyRowMapper<UserBean>(UserBean.class);
        UserBean user=this.getJdbcTemplate().queryForObject(sql, rowMapper);
        System.out.println(user.getUserName()+"年龄为：" +user.getAge());
    }
    
    
    private void queryForPrepared() {
        String sql="select * from user where userName like ?";
        
        BeanPropertyRowMapper<UserBean> rowMapper=new BeanPropertyRowMapper<UserBean>(UserBean.class);
        List<UserBean> userList=this.getJdbcTemplate().query(sql, new PreparedStatementSetter(){

            public void setValues(PreparedStatement ps) throws SQLException {
                ps.setString(1, "%三");
            }
                   
        }, rowMapper);
        
        for(UserBean user:userList){
            
            System.out.println(user.getUserName());
        }

    }
    
    
    private void queryForPreparedName() {
        String sql="select * from user where userName like :userName";
        
        NamedParameterJdbcTemplate template=new NamedParameterJdbcTemplate(this.getDataSource());
        
        BeanPropertyRowMapper<UserBean> rowMapper=new BeanPropertyRowMapper<UserBean>(UserBean.class);
        UserBean userbean=new UserBean();
        userbean.setUserName("%四");
        BeanPropertySqlParameterSource sqlParameterSource=new BeanPropertySqlParameterSource(userbean);
        
        List<UserBean> userList=    template.query(sql,sqlParameterSource , rowMapper);
        
        for(UserBean user:userList){
            System.out.println(user.getUserName());
        }

    }
    
    
    public static void main(String[] args) {
        ApplicationContext context=new ClassPathXmlApplicationContext("spring.xml");
    
        Test_Query test_Query=(Test_Query) context.getBean("test_Query");

    //    test_Query.queryForList();
    //    test_Query.queryForMap();
    //    test_Query.queryForObject();
        
    //    test_Query.queryForBean();
    //    test_Query.queryForPrepared();
        test_Query.queryForPreparedName();
    }
}

spring.xml

<bean id="dateSource" class="org.springframework.jdbc.datasource.DriverManagerDataSource">
        <!-- 推荐使用配置文件的方法来设置数据源的参数-->
        
        <constructor-arg index="0" name="driverClassName" value="com.mysql.jdbc.Driver"></constructor-arg>
        <!-- xml文件中不能直接用&号，要用"&amp;"取代，否则报错，如下 -->
        <constructor-arg index="1" value="jdbc:mysql://127.0.0.1:3306/user?useUnicode=true&amp;characterEncoding=UTF-8"></constructor-arg>
        <constructor-arg index="2" name="username" value="root"></constructor-arg>
        <constructor-arg index="3" name="password" value=""></constructor-arg>
    </bean>

    <bean id="jdbctemplate" class="org.springframework.jdbc.core.JdbcTemplate">
        <property name="dataSource" ref="dateSource"></property>
    </bean>

<!-- test_Query类中需要的配置 -->
    <bean id="test_Query" class="jdbc.Test_Query">
        <property name="jdbcTemplate" ref="jdbctemplate"></property>
    </bean>
    <!-- end -->

结果：

P6SPY 的作用：我们知道预处理语句里包含？号，这不利于我们调试程序，P6SPY和spring配合可以显示真正的SQL语句。
步骤：

1、添加p6spy.jar。

2、将spy.properties放到src下，最后部署到类路径下。

3、修改spy.properties中的数据库驱动， driverlist=com.mysql.jdbc.Driver（根据自己的数据库类型，解开注释，这里使用mysql。）

4.修改sql日志的输出方式，第三个是输出到控制台，第四个是输出到文件。以下是设置为控制台输出
#specifies the appender to use for logging
#appender=com.p6spy.engine.logging.appender.Log4jLogger
appender=com.p6spy.engine.logging.appender.StdoutLogger
#appender=com.p6spy.engine.logging.appender.FileLogger

5.配置spring.xml

    <bean id="dateSource" class="com.p6spy.engine.spy.P6DataSource">
        <constructor-arg ref="dateSourcetarget"></constructor-arg>
    </bean>
    
    
    <bean id="dateSourcetarget" class="org.springframework.jdbc.datasource.DriverManagerDataSource">
        <!-- 推荐使用配置文件的方法来设置数据源的参数-->
        
        <constructor-arg index="0" name="driverClassName" value="com.mysql.jdbc.Driver"></constructor-arg>
        <!-- xml文件中不能直接用&号，要用"&amp;"取代，否则报错，如下 -->
        <constructor-arg index="1" value="jdbc:mysql://127.0.0.1:3306/user?useUnicode=true&amp;characterEncoding=UTF-8"></constructor-arg>
        <constructor-arg index="2" name="username" value="root"></constructor-arg>
        <constructor-arg index="3" name="password" value=""></constructor-arg>
    </bean>

结果：

可见，如果有预编译语句，p6spy都会在控制台里打印出这个语句的完整句子。

以上所有例子源代码都在这里：链接

查看全文

相关阅读:
正则表达式（四）--文本换行分割
 java加密类型和算法名称
 记事本记录日志
 DNS
jstl--c:choose标签
 csv文本编辑引号问题
 JDBC----ReflectionUtils
Jsp
计算机网络编程总结：
N颗骰子的问题

原文地址：https://www.cnblogs.com/shyroke/p/6714691.html