Spring中JDBCTemplate的入门

Spring是IOC和AOP的容器框架,一站式的框架

连接数据库的步骤:[必须会写]

Spring当中如何配置连接数据库?

第一步配置核心配置文件:

<?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-4.2.xsd

http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-4.2.xsd">

<!-- 启动Spring注解 -->

<context:annotation-config/>

<!-- 扫描,如果有多个使用逗号分隔 -->

<context:component-scan base-package="com.shxt"/>

<!-- 加载属性文件,classpath和classpath*的区别 -->

<context:property-placeholder location="classpath:/jdbc.properties"/>

<!-- 配置数据源信息 -->

<bean id="shxtDataSource" class="org.springframework.jdbc.datasource.DriverManagerDataSource" >

<property name="driverClassName" value="${jdbc.driver}"/>

<property name="url" value="${jdbc.url}"/>

<property name="username">

<value>${jdbc.username}</value>

</property>

<property name="password" value="${jdbc.password}"/>

</bean>

<!-- 配置完成 -->

<bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">

<property name="dataSource" ref="shxtDataSource"/>

</bean> 

</beans> 

package com.shxt.test;

import org.junit.Before;

import org.junit.Test;

import org.springframework.context.ApplicationContext;

import org.springframework.context.support.ClassPathXmlApplicationContext;

import org.springframework.jdbc.core.JdbcTemplate;

public class JDBCTest {

private ApplicationContext ac =null;

private JdbcTemplate jdbcTemplate = null;

@Before

public void init(){

//读取核心配置文件

ac = new ClassPathXmlApplicationContext("beans.xml");

//获取JdbcTemplate对象,通过id的方式, JdbcTemplate.class就是强转

jdbcTemplate = ac.getBean("jdbcTemplate",JdbcTemplate.class);//强转

}

@Test

public void 添加角色的操作_第一种方式(){

String sql = "insert into sys_role(role_name,role_desc) values ('悟空','齐天大圣')";

//不正规

//默认情况下JDBC的事务是自动提交的,而大部分的持久层框架是需要手动提交的

int rownum = jdbcTemplate.update(sql);//delete/update/insert的sql语句

System.out.println(rownum);

}

 } 

代码优化

<?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"

xmlns:p="http://www.springframework.org/schema/p"

xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-4.2.xsd

http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-4.2.xsd">

<!-- 启动Spring注解 -->

<context:annotation-config/>

<!-- 扫描,如果有多个使用逗号分隔 -->

<context:component-scan base-package="com.shxt"/>

<!-- 加载属性文件,classpath和classpath*的区别 -->

<context:property-placeholder location="classpath:/jdbc.properties"/>

<!-- 配置数据源信息 -->

<bean id="shxtDataSource" class="org.springframework.jdbc.datasource.DriverManagerDataSource"

p:driverClassName="${jdbc.driver}" p:url="${jdbc.url}" p:username="${jdbc.username}" p:password="${jdbc.password}"

/>

<bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate"

p:dataSource-ref="shxtDataSource"

/>

</beans>

代码说明:

<bean id="shxtDataSource" class="org.springframework.jdbc.datasource.DriverManagerDataSource"

p:driverClassName[对应的是set方法]="${jdbc.driver}"
p:url[对应的是set方法]="${jdbc.url}" p:username[对应的是set方法]="${jdbc.username}"
p:password[对应的是set方法]="${jdbc.password}"

/>

<bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate"

p:dataSource[对应的是set方法]-ref[引用]="shxtDataSource"

/>

@Test

public void 添加角色的操作_第二种方式_推荐方式_预处理方式(){

String sql = "insert into sys_role(role_name,role_desc) values (?,?)";

//int rownum = jdbcTemplate.update(sql, new Object[]{"八戒","天蓬元帅"});

int rownum = jdbcTemplate.update(sql, "八戒","天蓬元帅");

System.out.println(rownum);

}

如果使用Hibernate或者Mybatis类似的持久层框架,他们都可以通过配置返回你添加数据的主键

Mybatis是如何配置?请补充代码,映射文件内容

 

有待补充

---->>>> 如果涉及到Oracle数据库,建议使用官方写法,因为Oracle没有自增长的字段,是通过序列完成自增长操作

final String INSERT_SQL = "insert into my_test (name) values(?)"; // 老版本因为是内部类,所有需要使用final
final String name = "Rob";

KeyHolder keyHolder = new GeneratedKeyHolder();
jdbcTemplate.update(
new PreparedStatementCreator() {
public PreparedStatement createPreparedStatement(Connection connection) throws SQLException {
PreparedStatement ps = connection.prepareStatement(INSERT_SQL, new String[] {"id"});//id为主键字段
ps.setString(1, name);//PreparedStatement 1代表第一个问好
return ps;
}
},
keyHolder);

// keyHolder.getKey() now contains the generated key

@Test

public void 添加角色的操作_关于主键_前提必须使用自增长的方式(){

String sql = "insert into sys_role(role_name,role_desc) values (?,?)";

Role role = new Role();

role.setRole_name("唐僧");

role.setRole_desc("金蝉子");

KeyHolder keyHolder = new GeneratedKeyHolder();//使用Ctrl+T的方式,看KeyHolder的实现类

jdbcTemplate.update(new PreparedStatementCreator() {

@Override //一期内容

public PreparedStatement createPreparedStatement(Connection con) throws SQLException {

//1.获取预处理对象

PreparedStatement ps = con.prepareStatement(sql, Statement.RETURN_GENERATED_KEYS);

ps.setString(1, role.getRole_name());//注意 1代表的是第一个问号

ps.setString(2, role.getRole_desc());//注意 2代表的是第二个问号

return ps;

}

}, keyHolder);

int pk = keyHolder.getKey().intValue();//getKey()返回为Number类型

role.setRole_id(pk);

System.out.println(role.getRole_id());

}

关于更新操作和删除操作类似,如果涉及到批量添加和更新问题,请自行扩展学习

测试查询操作:

@Test

public void 通过查询返回单一的值(){

String sql = "select count(*) from sys_role where role_name like ?";

Integer count = jdbcTemplate.queryForObject(sql, Integer.class, "%1%");//Integer.class 强转

//Integer count = jdbcTemplate.queryForObject(sql, new Object[]{"%员%"}, Integer.class);

System.out.println(count);

}

返回一条数据的形式:

@Test

public void 返回一条数据_Map形式(){

String sql = "select * from sys_role where role_id=?";

Map<String,Object> map = jdbcTemplate.queryForMap(sql, 405);

System.out.println(map);

}

@Test

public void 返回一条数据_对象形式(){

String sql = "select * from sys_role where role_id=?";//一期关系

Role role = jdbcTemplate.queryForObject(sql, new Object[]{405},new RowMapper<Role>(){

@Override //Java的内部类?匿名类?

public Role mapRow(ResultSet rs, int rowNum) throws SQLException {

Role role = new Role();

role.setRole_id(rs.getInt("role_id"));

role.setRole_name(rs.getString("role_name"));

role.setRole_desc(rs.getString("role_desc"));

role.setRole_photo(rs.getString("role_photo"));

role.setRole_status(rs.getString("role_status"));

return role;

}

});

System.out.println(role);

}

返回列表数据

@Test

public void 返回列表数据_List_Map形式(){

String sql = "select * from sys_role where role_name like ?";

List<Map<String,Object>> dataList = jdbcTemplate.queryForList(sql, "%1%");

System.out.println(dataList);

}

@Test

public void 返回列表数据_List_对象形式(){

String sql = "select * from sys_role where role_name like ?";

List<Role> roleList = jdbcTemplate.query(sql, new Object[]{"%员%"}, new RowMapper<Role>(){

@Override

public Role mapRow(ResultSet rs, int rowNum) throws SQLException {

Role role = new Role();

role.setRole_id(rs.getInt("role_id"));

role.setRole_name(rs.getString("role_name"));

role.setRole_desc(rs.getString("role_desc"));

role.setRole_photo(rs.getString("role_photo"));

role.setRole_status(rs.getString("role_status"));

return role;

}

});

System.out.println(roleList);

}

我们发现 返回列表数据_List_对象形式()和返回一条数据_对象形式() 中的代码有重复性质!

public class RoleRowMapper implements RowMapper<Role> { 

@Override

public Role mapRow(ResultSet rs, int rowNum) throws SQLException {

Role role = new Role();

role.setRole_id(rs.getInt("role_id"));

role.setRole_name(rs.getString("role_name"));

role.setRole_desc(rs.getString("role_desc"));

role.setRole_photo(rs.getString("role_photo"));

role.setRole_status(rs.getString("role_status"));

return role;

} 

}

@Test

public void 返回一条数据_对象形式_优化(){

String sql = "select * from sys_role where role_id=?";//一期关系

Role role = jdbcTemplate.queryForObject(sql, new Object[]{405},new RoleRowMapper()); //实现类

System.out.println(role);

}

@Test

public void 返回列表数据_List_对象形式_优化(){

String sql = "select * from sys_role where role_name like ?";

List<Role> roleList = jdbcTemplate.query(sql, new Object[]{"%员%"}, new RoleRowMapper()); //实现类

System.out.println(roleList);

}

个人推荐: 超精简版[自己命名的,私人珍藏],通过领域模型自动完成映射

@Test //你需要保持数据库的字段名和属性名保持一致,[没有说完全一致]

public void 返回一条数据_对象形式_超精简版(){

String sql = "select * from sys_role where role_id=?";//一期关系

Role role = jdbcTemplate.queryForObject(sql, new Object[]{405},new BeanPropertyRowMapper<Role>(Role.class));

System.out.println(role);

}

@Test

public void 返回列表数据_List_对象形式_超精简版(){

String sql = "select * from sys_role where role_name like ?";

List<Role> roleList = jdbcTemplate.query(sql, new Object[]{"%员%"}, new BeanPropertyRowMapper<Role>(Role.class));

System.out.println(roleList);

}

@Test

public void 返回列表数据_List_对象形式_超精简版_一致的解释(){

String sql = "select role_name , role_desc role_photo1 from sys_role";

List<Role> roleList = jdbcTemplate.query(sql, new BeanPropertyRowMapper<Role>(Role.class));

System.out.println(roleList);

}

模拟权限分配操作

@Test

public void 权限分配() throws Exception{

//1.客户端复选框传递过来一个数组 1,2 菜单的ID

Integer[] menus = new Integer[]{1,2};

//2.声明数组

String[] sqls = new String[menus.length+1];//0,1,2

//3.通过ROle_Id 200 删除中间表的信息

sqls[0] = "delete from role_link_menu where fk_role_id=200";//

//3.新数据添加到中间表

for (int i=0;i<menus.length;i++) {

//1,2

sqls[i+1] = "insert into role_link_menu (id,fk_role_id,fk_menu_id) values ('"+UUID.randomUUID().toString()+"',200,"+menus[i]+")";

}

jdbcTemplate.batchUpdate(sqls);

//MyBatis的实现方式

}

-----------------------------------------

********等价操作*********

-----------------------------------------

通过MyBatis的实现方式,自学内容,MySQL下的操作,设置如下!

&allowMultiQueries=true 新增内容如下:

 

shxt.driver=com.mysql.jdbc.Driver

shxt.url=jdbc:mysql://127.0.0.1:3308/xy37_rbac??useUnicode=true&characterEncoding=UTF-8&allowMultiQueries=true

shxt.username=root

shxt.password=shxt

接口中定义方法,如下推荐使用Map

public void permission(Map<String,Object> map); 

映射文件代码如下:

<delete id="permission" parameterType="map" statementType="PREPARED">

DELETE FROM role_link_menu WHERE fk_role_id=#{role_id};

<foreach collection="menus" item="menu_id" >

INSERT INTO role_link_menu (id, fk_role_id, fk_menu_id) VALUES ((SELECT UUID()),#{role_id},#{menu_id});

</foreach>

</delete>

测试代码:

@Test

public void 多条SQL语句执行(){

SqlSession sqlSession = null;

try {

sqlSession = MyBatisUtils.getSqlSession();

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

map.put("role_id", 200);

map.put("menus", new Object[]{1,2,3,6});

sqlSession.getMapper(UserMapper.class).permission(map);

sqlSession.commit();

} catch (Exception e) {

e.printStackTrace();

}finally {

MyBatisUtils.closeSqlSession(sqlSession);

}

}