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

Z时代
2024-01-10
分类：综合

本文内容纲要：（二）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文件中不能直接用&号，要用"&"取代，否则报错，如下 -->
        <constructor-arg index="1" value="jdbc:mysql://127.0.0.1:3306/user?useUnicode=true&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文件中不能直接用&号，要用"&"取代，否则报错，如下 -->
        <constructor-arg index="1" value="jdbc:mysql://127.0.0.1:3306/user?useUnicode=true&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文件中不能直接用&号，要用"&"取代，否则报错，如下 -->
        <constructor-arg index="1" value="jdbc:mysql://127.0.0.1:3306/user?useUnicode=true&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

    <constructor-arg index="0" name="driverClassName" value="com.mysql.jdbc.Driver"></constructor-arg>
    <!-- xml文件中不能直接用&号，要用"&"取代，否则报错，如下 -->
    <constructor-arg index="1" value="jdbc:mysql://127.0.0.1:3306/user?useUnicode=true&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文件中不能直接用&号，要用"&"取代，否则报错，如下 -->
        <constructor-arg index="1" value="jdbc:mysql://127.0.0.1:3306/user?useUnicode=true&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文件中不能直接用&号，要用"&"取代，否则报错，如下 -->
        <constructor-arg index="1" value="jdbc:mysql://127.0.0.1:3306/user?useUnicode=true&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文件中不能直接用&号，要用"&"取代，否则报错，如下 -->
        <constructor-arg index="1" value="jdbc:mysql://127.0.0.1:3306/user?useUnicode=true&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文件中不能直接用&号，要用"&"取代，否则报错，如下 -->
        <constructor-arg index="1" value="jdbc:mysql://127.0.0.1:3306/user?useUnicode=true&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文件中不能直接用&号，要用"&"取代，否则报错，如下 --> <constructor-arg index="1" value="jdbc:mysql://127.0.0.1:3306/user?useUnicode=true&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文件中不能直接用&号，要用"&"取代，否则报错，如下 -->
        <constructor-arg index="1" value="jdbc:mysql://127.0.0.1:3306/user?useUnicode=true&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都会在控制台里打印出这个语句的完整句子。

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

本文内容总结：（二）Spring框架之JDBC的基本使用（p6spy插件的使用）

原文链接：https://www.cnblogs.com/shyroke/p/6714691.html

以上是（二）Spring框架之JDBC的基本使用（p6spy插件的使用）的全部内容，来源链接： utcz.com/z/362686.html