SSM Day6

Spring——JdbcTemplate

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:context="http://www.springframework.org/schema/context"
	xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
		http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-4.0.xsd">
	
	<context:component-scan base-package="com.atguigu"></context:component-scan>

	<!--引入外部配置文件  -->
	<context:property-placeholder location="classpath:dbconfig.properties"/>

	<!-- 实验1：测试数据源
	${}取出配置文件中的值
	#{}Spring的表达式语言
	 -->
	<bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
		<property name="user" value="${jdbc.user}"></property>
		<property name="password" value="${jdbc.password}"></property>
		<property name="jdbcUrl" value="${jdbc.jdbcUrl}"></property>
		<property name="driverClass" value="${jdbc.driverClass}"></property>
	</bean>
	
	<!-- Spring提供了一个类JdbcTemplate，我们用它操作数据库；
		导入Spring的数据库模块
			spring-jdbc-4.0.0.RELEASE.jar
			spring-orm-4.0.0.RELEASE.jar
			spring-tx-4.0.0.RELEASE.jar
		 -->
	<bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">
		<constructor-arg name="dataSource" ref="dataSource"></constructor-arg>
	</bean>
	
	<!-- 配置一个具有  具名参数  功能的JdbcTemplate；NamedParameterJdbcTemplate -->
	<bean id="namedParameterJdbcTemplate" class="org.springframework.jdbc.core.namedparam.NamedParameterJdbcTemplate">
		<!-- 使用构造器方式注入一个数据源 -->
		<constructor-arg name="dataSource" ref="dataSource"></constructor-arg>
	</bean>
</beans>

TxTest.java

public class TxTest {
	
	ApplicationContext ioc = new ClassPathXmlApplicationContext("ApplicationContext.xml");
	JdbcTemplate jdbcTemplate = ioc.getBean(JdbcTemplate.class);
	NamedParameterJdbcTemplate namedJdbcTemplate = ioc.getBean(NamedParameterJdbcTemplate.class);
	
	/**
	 * 实验9：创建BookDao，自动装配JdbcTemplate对象
	 */
	@Test
	public void test09(){
		EmployeeDao bean = ioc.getBean(EmployeeDao.class);
		Employee employee = new Employee();
		employee.setEmpName("哈哈2");
		employee.setSalary(998.98);
		bean.saveEmployee(employee);
	}
	
	/**
	 * 实验8：重复实验7，以SqlParameterSource形式传入参数值
	 */
	@Test
	public void test08(){
		String sql = "INSERT INTO employee(emp_name,salary) VALUES(:empName,:salary)";
		Employee employee = new Employee();
		employee.setEmpName("哈哈");
		employee.setSalary(998.98);
		
		//
		int i = namedJdbcTemplate.update(sql, new BeanPropertySqlParameterSource(employee));
		System.out.println(i);
		
	}
	
	/**
	 * 实验7：使用带有具名参数的SQL语句插入一条员工记录，并以Map形式传入参数值
	 * 
	 * 具名参数：（具有名字的参数，参数不是占位符了，而是一个变量名）
	 * 		语法格式：   :参数名
	 * Spring有一个支持具名参数功能的JdbcTemplate
	 * 
	 * 占位符参数：?的顺序千万不能乱。传参的时候一定注意；
	 */
	@Test
	public void test07(){
		String sql = "INSERT INTO employee(emp_name,salary) VALUES(:empName,:salary)";
		
		//Map
		Map<String, Object> paramMap = new HashMap<>();
		//将所有具名参数的值都放在map中；
		paramMap.put("empName", "田七");
		paramMap.put("salary", 9887.98);
		int update = namedJdbcTemplate.update(sql, paramMap);
		System.out.println(update);
	}
	
	
	/**
	 * 实验6：查询最大salary
	 */
	@Test
	public void test06(){
		String sql = "select max(salary) from employee";
		//无论是返回单个数据还是单个对象，都是调用queryForObject
		Double object = jdbcTemplate.queryForObject(sql, Double.class);
		System.out.println(object);
	}
	
	
	/**
	 * 实验5：查询salary>4000的数据库记录，封装为List集合返回
	 */
	@Test
	public void test05(){
		String sql = "SELECT emp_id empId,emp_name empName,salary FROM employee WHERE salary>?";
		//封装List；集合里面元素的类型
		List<Employee> list = jdbcTemplate.query(sql, new BeanPropertyRowMapper<>(Employee.class), 4000);
		
		for (Employee employee : list) {
			System.out.println(employee);
		}
	}
	
	/**
	 * 实验4：查询emp_id=5的数据库记录，封装为一个Java对象返回；
	 * javaBean需要和数据库中字段名一致，否则无法完成封装；
	 * 
	 * jdbcTemplate在方法级别进行了区分
	 * 查询集合：jdbcTemplate.query()
	 * 查询单个对象：jdbcTemplate.queryForObject()
	 * 		如果查询没结果就报错；
	 * 
	 */
	@Test
	public void test04(){
		String sql = "SELECT emp_id empId,emp_name empName,salary FROM employee WHERE emp_id=?";	
		//RowMapper：每一行记录和javaBean的属性如何映射
		Employee employee = null;
		try {
			employee = jdbcTemplate.queryForObject(sql, new BeanPropertyRowMapper<>(Employee.class), 50);
		} catch (DataAccessException e) {
			
		}
		System.out.println(employee);
	}
	
	
	/**
	 * 实验3：批量插入；
	 */
	@Test
	public void test03(){
		String  sql ="INSERT INTO employee(emp_name,salary) VALUES(?,?)";
		//List<Object[]>
		//List的长度就是sql语句要执行的次数
		//Object[]：每次执行要用的参数
		List<Object[]> batchArgs = new ArrayList<Object[]>();
		batchArgs.add(new Object[]{"张三",1998.98});
		batchArgs.add(new Object[]{"李四",2998.98});
		batchArgs.add(new Object[]{"王五",3998.98});
		batchArgs.add(new Object[]{"赵六",4998.98});
		
		int[] is = jdbcTemplate.batchUpdate(sql, batchArgs);
		for (int i : is) {
			System.out.println(i);
		}
	}
	
	/**
	 * 实验2：将emp_id=5的记录的salary字段更新为1300.00
	 */
	@Test
	public void test02(){
		String sql = "UPDATE employee SET salary=? WHERE emp_id=?";
		int update = jdbcTemplate.update(sql, 1300.00,5);
		System.out.println("更新员工："+update);
	}
	
	@Test
	public void test() throws SQLException {
		DataSource bean = ioc.getBean(DataSource.class);
		Connection connection = bean.getConnection();
		System.out.println(connection);
		connection.close();
		
	}
	
	@Test
	public void test01() throws SQLException {
		System.out.println(jdbcTemplate);
	}
	
}