JAVA互联网架构学习之JdbcTemplate

1.Spring提供的一个操作数据库的技术JdbcTemplate，是对Jdbc的封装。语法风格非常接近DBUtils。

  JdbcTemplate可以直接操作数据库，加快效率，而且学这个JdbcTemplate也是为声明式事务做准备，毕竟要对数据库中的数据进行操纵！

  JdbcTemplate中并没有提供一级缓存，以及类与类之间的关联关系！就像是spring提供的一个DBUtils。

  Spring对数据库的操作使用JdbcTemplate来封装JDBC，结合Spring的注入特性可以很方便的实现对数据库的访问操作。使用JdbcTemplate可以像JDBC一样来编写数据库

的操作代码  

2.为啥要使用Jdbc_template进行开发呢？

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

Spring提供的JdbcTemplate对jdbc做了封装，大大简化了数据库的操作。找到Spring JdbcTemplate源码，可以看到如下方法：

Connection con = DataSourceUtils.getConnection(getDataSource());

如果直接使用JDBC的话，需要我们加载数据库驱动、创建连接、释放连接、异常处理等一系列的动作；繁琐且代码看起来不直观。

此外，Spring提供的JdbcTempate能直接数据对象映射成实体类，不再需要获取ResultSet去获取值/赋值等操作，提高开发效率；

如下：

return (User) jdbcTemplate.queryForObject("select * from tb_test1 where id = 100", User.class)

3.配置环境

①导入jar包

[1]IOC容器需要的jar包
commons-logging-1.1.3.jar

spring-aop-4.0.0.RELEASE.jar  //注解会使用到的包

spring-beans-4.0.0.RELEASE.jar

spring-context-4.0.0.RELEASE.jar

spring-core-4.0.0.RELEASE.jar

spring-expression-4.0.0.RELEASE.jar

[2]MySQL驱动、C3P0jar包

c3p0-0.9.1.2.jar

mysql-connector-java-5.1.37-bin.jar

[3]JdbcTemplate需要的jar包

spring-jdbc-4.0.0.RELEASE.jar

spring-orm-4.0.0.RELEASE.jar

spring-tx-4.0.0.RELEASE.jar

②在IOC容器中配置数据源

		<!-- 加载properties文件中 信息 -->
		<context:property-placeholder location="classpath:jdbc.properties"/>
		<!-- 配置数据源 -->
		<bean id="comboPooledDataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
			<property name="user" value="${jdbc.user}"></property>
			<property name="password" value="${jdbc.passowrd}"></property>
			<property name="jdbcUrl" value="${jdbc.url}"></property>
			<property name="driverClass" value="${jdbc.driver}"></property>
		</bean>

其中jdbc.properties文件内容：
jdbc.user=root
jdbc.passowrd=123456
jdbc.url=jdbc:mysql://localhost:3306/test
jdbc.driver=com.mysql.jdbc.Driver

   
③在IOC容器中配置JdbcTemplate对象的bean，并将数据源对象装配到JdbcTemplate对象中.

		<!-- 配置JdbcTemplate对应的bean， 并装配dataSource数据源属性-->
		<bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">
			<property name="dataSource" ref="comboPooledDataSource"></property>
		</bean>

4.实验

获取IOC容器 private ApplicationContext IOC = new ClassPathXmlApplicationContext("applicationContext.xml"); 

获取JdbcTemplate的bean   private JdbcTemplate template = IOC.getBean(JdbcTemplate.class);

以下代码均在Junit的@Test注解的函数中

1.测试数据源

		DataSource bean = IOC.getBean(DataSource.class);
		System.out.println(bean.getConnection());

2.更新操作

（trade为一个（String name , Int money）的表）

更新

		String sql="update trade set money = money + ? where name = ?";
		template.update(sql, -100,"testMan");//第一个是sql语句，后面的按着顺序传入参数即可，这个update方法是接收的可变参数！

删除

		String sql="delete from trade where name = ?";
		template.update(sql,"testMan");

插入

		String sql="insert into trade values(?,?)";
		template.update(sql, "testMan",3200);

从上述实验中就可以看到，该操作不用我们自己再去获取数据库连接信息了，而是直接传递sql语句及其参数！

3.批量操作

删除

		String sql="delete from trade where name = ?";
		List<Object[]> list=new ArrayList<>();
		list.add(new Object[] {"test1"});
		list.add(new Object[] {"test2"});
		list.add(new Object[] {"test3"});
		template.batchUpdate(sql, list);

插入

		String sql="insert into trade values(?,?)";
		List<Object[]> list = new ArrayList<Object[]>();
		list.add(new Object[]{"test1",1500});
		list.add(new Object[]{"test2",1300});
		list.add(new Object[] {"test3",3200});
		template.batchUpdate(sql, list);

注意batchUpdate()中传入的list必须为Object [ ] 的集合，哪怕只有一个变量

4.查询name = 'testMan' 的数据库记录，封装为一个User对象返回

		String sql ="select name AS name,money AS money from trade where name = ?";//需要注意的是：sql语句中的别名要与对应实体类的属性名保持一致！
		RowMapper<User> rowmap=new BeanPropertyRowMapper<User>(User.class);//RowMapper是一个接口,这里我们使用其子类
		User user=template.queryForObject(sql, rowmap,"testMan");//最后一个参数是可变参数，用于向sql语句中依次传递参数!
		System.out.println(user);

RowMapper意味将数据库的一行数据映射为一个对象

查询结果是一个实体还是一个list列表是靠template对象的不同方法实现的！

		String sql="select * from trade";
		RowMapper<User>rowMapper=new BeanPropertyRowMapper<User>(User.class);
		List<User> query = template.query(sql, rowMapper);
		for (User user : query) {
			System.out.println(user);
		}

5.查询最大money

		String sql="select MAX(money) from trade";
		Integer max = template.queryForObject(sql, Integer.class);
		System.out.println(max);

6.使用带有具名参数的SQL语句插入一条员工记录，并以Map形式传入参数值

具名参数:是指基于名称的，前面我们使用的都是用?作为占位符，然后是使用基于位置的！

如果要使用具名参数的sql语句就必须在spring配置文件中配置NamedParameterJdbcTemplat这个模板类，而不能使用

原来的JdbcTemplate，因为JdbcTemplate不能完成这样的任务！

			<!-- 为了执行带有具名参数的SQL语句，需要配置NamedParameterJdbcTemplate -->
			<!-- 该NamedParameterJdbcTemplate类没有无参构造器，需要传入JdbcTemplate对象或者数据源对象[DataSource] -->
			<bean id="namedParameterJdbcTemplate" class="org.springframework.jdbc.core.namedparam.NamedParameterJdbcTemplate">
				<!-- 不能使用property标签配置哦 -->
				<constructor-arg ref="jdbcTemplate"></constructor-arg>
			</bean>

在类中加入private NamedParameterJdbcTemplate namedJdbcTemplate = ioc.getBean(NamedParameterJdbcTemplate.class);

函数中

插入

		String sql="insert into trade values(:name,:money)";
				
		Map<String, Object> map = new HashMap<>();
		map.put("name", "Nero");
		map.put("money", 8888);
		namedParameterJdbcTemplate.update(sql, map);

批量插入，sql同上

		Map<String, Object>[]maps = new Map[3];
		maps[0]=new HashMap<>();
		maps[0].put("name", "test1");
		maps[0].put("money", 1234);
		
		maps[1]=new HashMap<>();
		maps[1].put("name", "test2");
		maps[1].put("money", 1234);
		
		maps[2]=new HashMap<>();
		maps[2].put("name", "test3");
		maps[2].put("money", 1234);
		
		namedParameterJdbcTemplate.batchUpdate(sql, maps);

7.以SqlParameterSource形式传入参数值

		String sql="insert into trade(`name`,`money`) values(:name,:money)";

		
		//该BeanPropertySqlParameterSource类构造器需要一个对象参数，该对象参数是一个封装了sql语句参数的对象！
		//此时要求对象的属性名要和sql中的参数名保持一致！这里我们使用Employee对象来完成
		User user = new User("Genji", 6666);
		//以实体对象的形式封装具名参数和值
		SqlParameterSource source = new BeanPropertySqlParameterSource(user);
		namedParameterJdbcTemplate.update(sql, source);

8.一般会创建JdbcTemplateDao，自动创配JdbcTemplate对象

  1.创建dao类：

@Repository
	public class JdbcTemplateDao {
		@Autowired
		private JdbcTemplate jdbcTemplate;
		
		public void update(String sql,Object ...args){
			jdbcTemplate.update(sql, args);
		}
	}

  2.配置spring的配置文件

<!-- 配置扫描的包 -->
				<context:component-scan base-package="com.neuedu.dao"></context:component-scan>
				<!-- 加载properties文件中 信息 -->
				<context:property-placeholder location="classpath:jdbc.properties"/>
				<!-- 配置数据源 -->
				<bean id="comboPooledDataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
					<property name="user" value="${jdbc.user}"></property>
					<property name="password" value="${jdbc.passowrd}"></property>
					<property name="jdbcUrl" value="${jdbc.url}"></property>
					<property name="driverClass" value="${jdbc.driver}"></property>
				</bean>
				
				<!-- 配置JdbcTemplate对应的bean， 并装配dataSource数据源属性-->
				<bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">
					<property name="dataSource" ref="comboPooledDataSource"></property>
				</bean>

3.测试该dao  

public class TestDataSource {
	private ApplicationContext ioc = new ClassPathXmlApplicationContext("applicationContext.xml");
	private NamedParameterJdbcTemplate namedJdbcTemplate = ioc.getBean(NamedParameterJdbcTemplate.class);
	
	@Test
	public void test01(){
		JdbcTemplateDao dao = ioc.getBean(JdbcTemplateDao.class);
		String sql = "INSERT INTO employee(`emp_name`,`salary`) VALUES(?,?)";
		dao.update(sql, "比尔盖茨",10000000);
	 
	}
}