spring(二)——spring-jdbc、spring中（QueryRunner、整合归纳连接池、常用注解、单元测试、纯注解实现业务逻辑）

Ⅰ、spring-jdbc 略

一般都使用mybatis操作数据库，不怎么使用spring-jdbc（术业有专攻）

一、简介

spring-jdbc见名知意，就是spring总框架提供的操作数据库的模块框架，其中核心类jdbcTemplate提供了一系列操作数据库的方法。

如何引入JDBCTemplate模块工具？
1）直接将JDBCTemplate作为属性引入
2）继承含义JDBCTemplate属性的父类JDBCDaoSupport工具类

如果是继承JDBCDaoSupport实现的引入，JDBCDaoSupport中定义了获取JDBCTemplate工具类的方法，从而可以简化配置（去掉JDBCTemplate的bean的配置）。不明白？见下面的配置配置文件👇

为什么不能直接继承JDBCTemplate完成引入？
莫有初始化

二、初步使用spring-jdbc

1、引入jar包
依赖核心容器的，所以需要核心容器的jar包

<!--spring核心容器的3个jar包-->
  <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-context</artifactId>
      <version>5.1.7.RELEASE</version>
  </dependency>
  <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-beans</artifactId>
      <version>5.1.7.RELEASE</version>
  </dependency>
  <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-core</artifactId>
      <version>5.1.7.RELEASE</version>
  </dependency>

引入spring-jdbc的jar包（注意与核心容器的版本相同）

<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-jdbc</artifactId>
    <version>5.1.7.RELEASE</version>
</dependency>

引入mysql驱动的jar包（注意自己的mysql版本）

<dependency>
    <groupId>mysql</groupId>
    <artifactId>mysql-connector-java</artifactId>
    <version>8.0.15</version>
</dependency>

引入c3p0连接池

<dependency>
     <groupId>com.mchange</groupId>
     <artifactId>c3p0</artifactId>
     <version>0.9.5.4</version>
 </dependency>

2、定义dao层接口，使用jdbcTemplate实现类的方法

使用jdbcTemplate实现类中的方法

查询
query返回集合,需要设置映射（什么是映射？这里就是将查询的数据与bean中的属性对应，并存放在bean中）
queryForObject返回一条数据,需要设置映射

增删改
update

package com.hbw.dao;

import com.hbw.bean.Student;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.jdbc.core.RowMapper;

import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.List;

public class StudentDaoImpl2 implements  StudentDao2{
    private JdbcTemplate jdbcTemplate;

    public void setJdbcTemplate(JdbcTemplate jdbcTemplate) {
        this.jdbcTemplate = jdbcTemplate;
    }
    /*增加*/
    @Override
    public void insertStudent(Student student) {
        String sql = "insert into student(sname) value(?)";
        jdbcTemplate.update(sql,student.getSname());
    }
    /*删除*/
    @Override
    public void deleteStudent(int sid) {
        String sql = "delete from student where sid=?";
        jdbcTemplate.update(sql,sid);

    }
    /*修改*/
    @Override
    public void upadateStudent(Student student) {
        String sql = "update  student set sname=? where sid=?";
        jdbcTemplate.update(sql,student.getSname(),student.getSid());
    }
    /*查询某一条数据*/
    @Override
    public Student selectStudent(int sid) {
        Student student = new Student();
        String sql ="select sid,sname from student where sid=?";
       /*查询一条数据，将查询结果与bean实体类进行映射*/
       jdbcTemplate.queryForObject(sql,new RowMapper<Student>() {
           @Override
           public Student mapRow(ResultSet rs, int rowNum) throws SQLException {
               student.setSid(rs.getInt("sid"));
               student.setSname(rs.getString("sname"));
               return student;
           }
       },sid);
       return student;
    }
    /*查询全部数据*/
    @Override
    public List<Student> selecteStudentAll() {
        String sql = "select sid,sname from student";
        return jdbcTemplate.query(sql, new RowMapper<Student>() {
            @Override
            public Student mapRow(ResultSet rs, int rowNum) throws SQLException {
                Student student = new Student();
                student.setSid(rs.getInt("sid"));
                student.setSname(rs.getString("sname"));
                return student;
            }
        });
    }



}

3、定义service
略

4、配置配置文件
附件——db.properties

db.driver=com.mysql.cj.jdbc.Driver
db.url=jdbc:mysql://localhost:3306/school?characterEncoding=utf-8&serverTimezone=UTC&useSSL=false
db.username=root
db.password=123456

<?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:aop="http://www.springframework.org/schema/aop"
       xmlns:context="http://www.springframework.org/schema/context"
       xsi:schemaLocation="http://www.springframework.org/schema/beans 
https://www.springframework.org/schema/beans/spring-beans.xsd
http://www.springframework.org/schema/aop 
https://www.springframework.org/schema/aop/spring-aop.xsd 
http://www.springframework.org/schema/context 
https://www.springframework.org/schema/context/spring-context.xsd">
    <!--引入属性配置文件-->
    <context:property-placeholder location="classpath:db.properties"></context:property-placeholder>
    <!--C3P0数据源-->
    <bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
        <property name="driverClass" value="${db.driver}"></property>
        <property name="jdbcUrl" value="${db.url}"></property>
        <property name="user" value="${db.username}"></property>
        <property name="password" value="${db.password}"></property>
    </bean>
    <!--初始化jdbcTemplate-->
    <bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">
        <property name="dataSource" ref="dataSource"></property>
    </bean>
    <!--初始化dao层，依赖注入jdbcTemplate-->
    <bean id="studentDao2" class="com.hbw.dao.StudentDaoImpl2">
       <property name="jdbcTemplate" ref="jdbcTemplate"></property>
    </bean>
    <!--初始化service层，依赖注入StudentDao2-->
    <bean id="studentService2" class="com.hbw.service.StudentServcieImpl2">
        <property name="studentDao2" ref="studentDao2"></property>
    </bean>

</beans>

5、测试

import com.hbw.bean.Student;
import com.hbw.service.StudentService2;
import org.junit.Before;
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

import java.util.List;

public class StudentTest2 {
    private StudentService2 studentService2;
    @Before
    public void before(){
        ApplicationContext applicationContext = new ClassPathXmlApplicationContext("springConfig2.xml");
        studentService2 = (StudentService2) applicationContext.getBean("studentService2");
    }
    /*测试spring-jdbc，查询全部操作*/
    @Test
    public void test1(){
        List<Student> studentList = studentService2.selecteStudentAll();
        for(Student student:studentList){
            System.out.println(student);
        }

    }
    /*测试spring-jdbc，查询一条数据*/
    @Test
    public  void test2(){
        System.out.println(studentService2.selectStudent(17));
    }
    /*测试spring-jdbc，删除操作*/
    @Test
    public  void  test3(){
        studentService2.deleteStudent(28);
    }
    /*测试spring-jdbc，修改操作*/
    @Test
    public  void  test4(){
        studentService2.upadateStudent(new Student(27,"十三",null,null,null,null,null));
    }
}

Ⅱ、QueryRunner 略

DBUTils工具类,和上面的spring-jdbc类似，只是包、类、方法名不一样……

思路：
引入jar包（spring核心容器、mysql、连接池、本身）——>编写dao层（熟悉的情况下可以先配置xml）——>编写servcie层——>配置xml——>测试

附上dao层和xml配置
dao层

package com.hbw.dao;

import com.hbw.bean.Student;
import com.mchange.v2.c3p0.ComboPooledDataSource;
import org.apache.commons.dbutils.QueryRunner;
import org.apache.commons.dbutils.handlers.BeanHandler;
import org.apache.commons.dbutils.handlers.BeanListHandler;

import java.sql.SQLException;
import java.util.List;

public class SyudentDaoDbutilImpl implements StudentDaoDbutil {
    private QueryRunner qr;

    public void setQr(QueryRunner qr) {
        this.qr = qr;
    }

    @Override
    public int insertStudent(Student student) {
        int rows = 0;
        String sql = "insert into student(sname,sage,ssex,semail) value(?,?,?,?)";
        try {
            rows = qr.update(sql,student.getSname(),student.getSage(),student.getSsex(),student.getSemail());
        } catch (SQLException e) {
            e.printStackTrace();
        }
        return rows;
    }

    @Override
    public int deleteStudent(int sid) {
        int rows = 0;
        String sql = "delete from student where sid=?";
        try {
            rows = qr.update(sql,sid);
        } catch (SQLException e) {
            e.printStackTrace();
        }
        return rows;
    }

    @Override
    public int updateStudent(Student student) {
        int rows = 0;
        String sql = "update student set sname=?,sage=?,ssex=?,semail=? where sid=?";
        try {
            rows = qr.update(sql,student.getSname(),student.getSage(),student.getSsex(),student.getSemail(),student.getSid());
        } catch (SQLException e) {
            e.printStackTrace();
        }
        return rows;
    }

    @Override
    public Student selectStudent(int sid) {
        Student student = null;
        String sql = "select sid,sname,sage,ssex,semail from student where sid=?";
        try {
            student = qr.query(sql,new BeanHandler<Student>(Student.class),sid);
        } catch (SQLException e) {
            e.printStackTrace();
        }
        return student;
    }

    @Override
    public List<Student> selectStudentAll() {
        List<Student> studentList = null;
        String sql = "select sid,sname,sage,ssex,semail from student";
        try {
            studentList = qr.query(sql,new BeanListHandler<>(Student.class));
        } catch (SQLException e) {
            e.printStackTrace();
        }
        return studentList;
    }
}

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:aop="http://www.springframework.org/schema/aop"
       xmlns:context="http://www.springframework.org/schema/context"
       xsi:schemaLocation="http://www.springframework.org/schema/beans 
https://www.springframework.org/schema/beans/spring-beans.xsd
http://www.springframework.org/schema/aop 
https://www.springframework.org/schema/aop/spring-aop.xsd 
http://www.springframework.org/schema/context 
https://www.springframework.org/schema/context/spring-context.xsd">
    <!--引入属性配置文件-->
    <context:property-placeholder location="classpath:db.properties"></context:property-placeholder>
    <!--初始化数据源-->
    <bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
        <property name="driverClass" value="${db.driver}"></property>
        <property name="jdbcUrl" value="${db.url}"></property>
        <property name="user" value="${db.username}"></property>
        <property name="password" value="${db.password}"></property>
    </bean>
    <!--初始化queryRunner,并依赖注入数据源（只提供了构造方法）-->
    <bean id="queryRunner" class="org.apache.commons.dbutils.QueryRunner">
        <constructor-arg ref="dataSource"></constructor-arg>
    </bean>
    <!--初始化StudentDaoDbutil,并依赖注入QueryRunner-->
    <bean id="studentDaoDbutil" class="com.hbw.dao.SyudentDaoDbutilImpl">
        <!--name属性的值，必须与类中的属性名相同-->
        <property name="qr" ref="queryRunner"></property>
    </bean>
    <!--初始化StudentServiceDbutil，并依赖注入StudentDaoDbutil-->
    <bean id="studentServiceDbutil" class="com.hbw.service.StudentServiceDbutilImpl">
        <property name="studentDaoDbutil" ref="studentDaoDbutil"></property>
    </bean>
</beans>

QueryRunner与Spring-jdbc总结

QueryRunner自动映射，所以bean实体类属性名必须与数据库字段名相同，不同需要取别名；配置数据源通过setter方法。
Spring-jdbc手动映射，所以属性名与字段名之间没有要求，写起来就比较麻烦，但是灵活；配置数据源通过构造方法。

Ⅲ、spring整合连接池

只是使用的jar包不一样，对应的接口、类和方法名就不一样，使用时没啥区别
一、C3P0连接池
1、jar包

<dependency>
    <groupId>com.mchange</groupId>
    <artifactId>c3p0</artifactId>
    <version>0.9.5.4</version>
</dependency>

2、配置文件

<bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
        <property name="driverClass" value="${db.driver}"></property>
        <property name="jdbcUrl" value="${db.url}"></property>
        <property name="user" value="${db.username}"></property>
        <property name="password" value="${db.password}"></property>
    </bean>

二、Druid连接池，常用
1、jar包

<dependency>
    <groupId>com.alibaba</groupId>
    <artifactId>druid</artifactId>
    <version>1.1.16</version>
</dependency>

2、配置文件
注意是通过键值对匹配的环境，是字符串类型，使用value

<bean id="druidDataSource" class="com.alibaba.druid.pool.DruidDataSource">
    <property name="driverClassName" value="${db.driver}"></property>
    <property name="url" value="${db.url}"></property>
    <property name="username" value="${db.username}"></property>
    <property name="password" value="${db.password}"></property>
</bean>

三、Dbcp连接池
1、jar包

<dependency>
    <groupId>commons-dbcp</groupId>
    <artifactId>commons-dbcp</artifactId>
    <version>1.4</version>
</dependency>

2、配置文件

<bean id="dbcpDataSource" class="org.apache.commons.dbcp.BasicDataSource">
    <property name="driverClassName" value="${db.driver}"></property>
    <property name="url" value="${db.url}"></property>
    <property name="username" value="${db.username}"></property>
    <property name="password" value="${db.password}"></property>
</bean>

四、spring-jdbc自带的连接池
1、jar包

<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-jdbc</artifactId>
    <version>5.1.7.RELEASE</version>
</dependency>

2、配置文件

<bean id="jdbcDataSource" class="com.mchange.v2.c3p0.DriverManagerDataSource">
    <property name="driverClass" value="${db.driver}"></property>
    <property name="jdbcUrl" value="${db.url}"></property>
    <property name="user" value="${db.username}"></property>
    <property name="password" value="${db.password}"></property>
</bean>

Ⅳ、spring配置文件引入

引入——就是添加的意思啦，比如下方把属性配置文件db.properties加到xml文件中，以便使用。

1.属性配置文件引入：<context:property-placeholder location="classpath:db.properties"></context:property-placeholder>
2.xml配置文件的引入：<import resource="classpath:springConfig.xml"></import>
注意：如果两个配置文件的id、name相同，后面加载的对象会覆盖前面加载的对象；

---

什么时候使用xml，什么时候使用注解？ 引用别人的框架（工具类）时，使用xml👆（主要是使用别人的类，莫法更改啊）；使用自己定义的代码使用注解👇

---

Ⅴ、spring常用注解

使用之前在xml加入扫描注解的语句，开启注解

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

注解	作用
@Controller	创建控制层实例，并标记该层是控制层
@Service	创建服务层实例，并标记该层为服务层
@Repository	创建持久层实例，并标记该层是持久层（dao层）
@Component	创建除了控制、服务、持久层以外的其他层实例
@Autowired	注解在属性上，可以自动注入属性对象，默认根据类型注入实例，因此可以不用提供set、构造方法
@Qualify	注解在属性上，搭配@Autowired使用，当同一个类型的实例有多个时，需要使用该注解来区别具体注入哪一个；通过id、name来注入具体对象
@Resources	注解在属性上，可以直接根据对象id、name注入对象实例（实际上不是spring注解，是jdk自带的）
@Value	注解在属性上，用于对普通类型数据赋值
@Bean	注解在方法上，返回实例
@Scope	指定实例的作用范围和配置文件中的scope属性相同

Ⅵ、spring-test单元测试

有什么作用?
spring提供的对JUnit的一种支持，这样就可以在test中使用@Autowired注解，自动注入所需要的bean。

一、引入jar包
是依赖junit的，记住导入JUnit的jar包和自己（spring-test）的jar包

<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-test</artifactId>
    <version>5.1.7.RELEASE</version>
</dependency>
<dependency>
    <groupId>junit</groupId>
    <artifactId>junit</artifactId>
    <version>4.12</version>
</dependency>

二、使用
注意，在类的外面加注解。ContextConfiguration可以扫描多个配置文件，所以是数组形式。classpath类路径，就是Resources文件夹

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(locations = {"classpath:springDBUTils.xml"})
public class StudentTest {
    @Autowired
    private StudentServiceDbutil studentServiceDbutil;
    ……
    ……
}

Ⅶ、纯注解实现业务 略

什么意思？
1）使用注解和使用xml配置的原则是——自定义的类使用注解；使用别人的框架（工具类）来完成业务就使用xml配置，主要是使用别人的代码，根本没必要也不好修改代码。
2）现在将别人的代码也直接通过自定义的工具类实例化和依赖注入；自定义的类保持👆的原则不变即可

1、创建一个使用注解初始化实例的工具类（将之前只能通过xml实例的对象，通过注解实例）
PureAnnotation.java

package com.hbw.util;

import com.alibaba.druid.pool.DruidDataSource;
import org.apache.commons.dbutils.QueryRunner;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.PropertySource;

///表示这是注解类
@Configuration
//扫描包下面的所有注解
@ComponentScan("com.hbw")
//扫描属性配置文件
@PropertySource("classpath:db.properties")
public class PureAnnotation {
    @Value("${db.driver}")
    private String driver;
    @Value("${db.url}")
    private String url;
    @Value("${db.username}")
    private String user;
    @Value("${db.password}")
    private String pwd;

    @Bean
    public DruidDataSource getDruidDataSource(){
        DruidDataSource druidDataSource = new DruidDataSource();
        druidDataSource.setDriverClassName(driver);
        druidDataSource.setUrl(url);
        druidDataSource.setUsername(user);
        druidDataSource.setPassword(pwd);
        return druidDataSource;
    }

    @Bean
    public QueryRunner getQueryRunner() {
    	 //实例化QueryRunner，并依赖注入DruidDataSource
        QueryRunner qr = new QueryRunner(getDruidDataSource());
        return  qr;
    }


    }

2、使用（本来可以直接使用注解实例和依赖注入的类直接使用注解即可，没必要阐述了）

@RunWith(SpringJUnit4ClassRunner.class)
//读取设置的工具类
@ContextConfiguration(classes = PureAnnotation.class )
public class StudentTest {
	……
	……
}