Spring---JDBCTemplate

JDBCTemplate

JDBCTemplate就是Spring对JDBC的在封装，方便对数据库进行操作。

在xml文件中

首先引入命名空间context，使用context:property-override标签引入外部properties文件，location指明位置

注入DruidDataSource的对象并完成属性注入，value内的内容可以直接注入，也能通过${ }【Spring表达式】进行获取配置文件中的内容

创建JDBCTemplate对象，将DruidDataSource对象注入进去

最后开启组件扫描

<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:p="http://www.springframework.org/schema/p"
       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.xsd">

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

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

    <bean id="jdbc" class="com.alibaba.druid.pool.DruidDataSource">
        <property name="driverClassName" value="${druid.DriverClassname}"></property>
        <property name="url" value="${druid.url}"></property>
        <property name="username" value="${druid.username}"></property>
        <property name="password" value="${druid.password}"></property>
    </bean>
<!--创建JDBCTemplate bean对象-->
    <bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">
        <property name="dataSource" ref="jdbc"></property>
    </bean>
</beans>

在DaoImpl类中

生成对象，注入JDBCTemplate的bean对象

@Repository
public class UserDaoImpl {
    @Autowired
    private JdbcTemplate jdbcTemplate;
}

在Service中

生成对象，注入DaoImpl对象

@Service
public class UserService {
    @Autowired
    private UserDao userDao;
}

使用JDBCTemplate操作数据库增加操作

首先创建一个Dao接口和实现类，添加注解创建对象，然后创建一个数据库表和实体类【代表数据库表的实体类中的属性要和数据库表中的列名一样，后面的查询操作会拿不到数据。因为是反射机制】

创建service层代码，并注入Dao接口的bean对象，调用接口方法

配置文件中【有错】

<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:p="http://www.springframework.org/schema/p"
       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.xsd">

    <context:component-scan base-package="xlw.com.jdbcTemplate"></context:component-scan>
    
    <context:property-override location="classpath:jdbc.properties"></context:property-override>
    
    <bean id="jdbc" class="com.alibaba.druid.pool.DruidDataSource">
        <property name="driverClassName" value="${druid.DriverClassname}"></property>
        <property name="url" value="${druid.url}"></property>
        <property name="username" value="${druid.username}"></property>
        <property name="password" value="${druid.password}"></property>
    </bean>

<!--创建JDBCTemplate bean对象-->
    <bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">
        <property name="dataSource" ref="jdbc"></property>
    </bean>
</beans>

Dao中

@Component
public interface UserDao {
    void add(User user);
}

DaoImpl中

@Repository
public class UserDaoImpl implements UserDao {
    @Autowired
    private JdbcTemplate jdbcTemplate;

    @Override
    public void add(User user) {
        String sql = "insert into o_User values (?,?,?)";
        int update = jdbcTemplate.update(sql, null, user.getUsername(), user.getPassword());
        System.out.println(update);
    }
}

Service中【没建立接口、直接调用的方法】

@Service
public class UserService {
    @Autowired
    private UserDao userDao;

    public void addUser(User user){
        userDao.add(user);
    }
}

随便建一个测试类

    ApplicationContext context = new ClassPathXmlApplicationContext("hao.xml");
@Test
public void testJDBCTemplate(){
    UserService userService = context.getBean("userService", UserService.class);
    User user = new User();
    user.setUsername("老王");
    user.setPassword("123abc");
    System.out.println(user.getPassword());
    userService.addUser(user);
}

问题出现了，本来输出一个影响行数但是报错了

Could not process key 'url' in PropertyOverrideConfigurer; nested exception is org.springframework.beans.factory.BeanInitializationException:
 Invalid key 'url': expected 'beanName.property'

这种的还有另一种说是jdbcTemplate建立的bean找不到，或者创建DaoImpl的bean出错，还有就是说表达式指向的内容找不到。其实这都是借口，问题是这个【DruidDataSource】类的bean对象的id他在上面叫jdbc，现在我改成了druid，然后在JDBCTemplate中注入这个bean就行，他就行了。神奇吧，神奇死了。

他半天一直在叫找不到jdbc这个bean在哪里，过一会又叫找不到druid这个bean在哪里。

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

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

<bean id="druid" class="com.alibaba.druid.pool.DruidDataSource" destroy-method="close">
    <property name="url" value="${druid.url}"></property>
    <property name="username" value="${druid.username}"></property>
    <property name="password" value="${druid.password}"></property>
    <property name="driverClassName" value="${druid.driverClassName}"></property>
</bean>
<!--创建JDBCTemplate bean对象-->
<bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">
    <property name="dataSource" ref="druid"></property>
</bean>

这时jdbc.properties文件【名字就叫这个】，mysql是8.0.21版本，可以自己去找对应的8.0.21的驱动jar包

druid.driverClassName=com.mysql.cj.jdbc.Driver
druid.url=jdbc:mysql://localhost:3308/o_user?characterEncoding=utf8&useSSL=true&serverTimezone=UTC
druid.username=root
druid.password=123456

JDBCTemplate对数据库表进行删除和修改

一样使用update方法，只是sql语句不一样。使用前先把语句拿到navicat里面试试行不行的通

剩下的就是调用了

@Override
public void update(User user) {
    String sql = "update o_USer set username=?,userpassword=? where id=?";
    int update = jdbcTemplate.update(sql, user.getUsername(), user.getPassword(), user.getUserid());
    System.out.println(update);
}

@Override
public void delete(User user) {
    String sql = "delete from o_User where id=?";
    int update = jdbcTemplate.update(sql, user.getUserid());
    System.out.println(update);
}

JDBCTemplate对数据库进行查询操作

返回数值

使用JDBCTemplate进行查询操作时，要用到方法queryForObject。将sql语句的查询结果返回为Integer类型。

@Override
public int selectCount() {
    String sql = "select count(*) from O_user";
    Integer count = jdbcTemplate.queryForObject(sql, Integer.class);
    return count;
}

返回对象

当希望返回类型是一个对象时，同样使用queryForObject方法，但是使用另一种参数结构，在方法中创建一个BeanPropertyRoMapper<>()对象，这个类实现了RowMapper接口，该接口可以真对不同返回类型的值，对数据做进一步的封装，里面的参数第一个是sql语句，第二个是这个BeanPropertyRowMapper对象,在它后面的泛型参数里加上返回的类对象，并在括号里注入泛型类对象的class，最后就是查询语句占位符对应的变量。

@Override
public User selectUserWithId(Integer id) {
    String sql = "select * from O_user where id=?";
    User user = jdbcTemplate.queryForObject(sql, new BeanPropertyRowMapper<User>(User.class), id);
    return user;
}

返回集合

在处理返回的方法上使用的query方法，它的参数和上面的那个BeanPropertyRowMapper接口实现类一样。在使用上注意就行了

@Override
public List<User> queryAllUser() {
    String sql = "select * from O_user";
    List<User> userList = jdbcTemplate.query(sql, new BeanPropertyRowMapper<User>(User.class));
    return userList;
}

JDBCTemplate对数据库进行批量操作

批量插入操作

在进行批量插入操作时使用方法batchUpdate，他第一个参数是sql语句，第二个参数是要插入的list数组集合。

@Override
public void batchAddUser(List<Object[]> list) {
    String sql = "insert into O_user values (?,?,?)";
    int[] lines = jdbcTemplate.batchUpdate(sql, list);
    System.out.println(Arrays.toString(lines));
}

插入时【纯是数组和对象插入的操作】

List<Object[]> object = new ArrayList<>();
 Object[] u1 = {null,"动物","猩猩"};
 Object[] u2 = {null,"植物","花"};
 Object[] u3 = {null,"鱼","石斑"};
 object.add(u1);
 object.add(u2);
 object.add(u3);
 userService.batchAdd(object);
 List<User> userList = userService.queryAllUser();

批量修改操作

在进行批量修改操作时，注意参数和占位符对应位置，不要设置错属性

@Override
public void batchUpdateByIdUser(List<Object[]> list) {
    String sql = "update o_USer set username=?,userpassword=? where id=?";
    int[] lines = jdbcTemplate.batchUpdate(sql, list);
    System.out.println(Arrays.toString(lines));
}

使用

List<Object[]> object = new ArrayList<>();
 Object[] u1 = {"动物","人",12};
 Object[] u2 = {"植物","树",13};
 Object[] u3 = {"鱼","泡泡",14};
 object.add(u1);
 object.add(u2);
 object.add(u3);
 userService.batchDeleteById(object);

批量删除操作

@Override
public void batchDeleteByIdUser(List<Object[]> list) {
    String sql = "delete from o_User where id=?";
    int[] ints = jdbcTemplate.batchUpdate(sql, list);
    System.out.println(Arrays.toString(ints));
}

使用

数组就是好，一两个、十个一百个。都能存进去

List<Object[]> object = new ArrayList<>();
 Object[] u1 = {12};
 Object[] u2 = {13};
 Object[] u3 = {14};
 object.add(u1);
 object.add(u2);
 object.add(u3);
 userService.batchDeleteById(object);

posted @ 2021-11-14 22:30 优质水阅读(105) 评论(0) 收藏举报

刷新页面返回顶部