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