springJDBC创建步骤

1、创建空Maven工程，添加pom.xml依赖包

加入依赖包之后，IDEA会提示下载依赖，点击下载依赖即可。

下载完毕之后点击Maven选项卡，点击Dependencies即可以看到已经下载好的依赖包

<properties>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <maven.compiler.source>11</maven.compiler.source>
        <maven.compiler.target>11</maven.compiler.target>
    </properties>
    <dependencies>
        <!--    lombok    -->
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <version>1.18.20</version>
        </dependency>
        <!--    junit测试    -->
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.13.1</version>
            <scope>test</scope>
        </dependency>
        <!--     扫描包annotation   -->
        <dependency>
            <groupId>javax.annotation</groupId>
            <artifactId>javax.annotation-api</artifactId>
            <version>1.3.1</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>5.2.4.RELEASE</version>
        </dependency>
        <!--   Spring测试     -->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-test</artifactId>
            <version>5.2.4.RELEASE</version>
            <scope>test</scope>
        </dependency>
        <!--   aop     -->
        <dependency>
            <groupId>org.aspectj</groupId>
            <artifactId>aspectjweaver</artifactId>
            <version>1.9.5</version>
        </dependency>
        <!--    spring jdbc    -->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-jdbc</artifactId>
            <version>5.2.4.RELEASE</version>
        </dependency>
        <!--    spring 事务    -->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-tx</artifactId>
            <version>5.2.4.RELEASE</version>
        </dependency>
        <!--    mysql驱动    -->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>8.0.19</version>
        </dependency>
        <!--   c3p0 连接池     -->
        <dependency>
            <groupId>com.mchange</groupId>
            <artifactId>c3p0</artifactId>
            <version>0.9.5.5</version>
        </dependency>
    </dependencies>
    <!--  静态资源导出问题  -->
    <build>
        <resources>
            <resource>
                <directory>src/main/java</directory>
                <includes>
                    <include>**/*.properties</include>
                    <include>**/*.xml</include>
                </includes>
                <filtering>false</filtering>
            </resource>
            <resource>
                <directory>src/main/resources</directory>
                <includes>
                    <include>**/*.properties</include>
                    <include>**/*.xml</include>
                </includes>
                <filtering>false</filtering>
            </resource>
        </resources>
    </build>

2、resources目录下创建.properties配置文件

配置.properties文件，用于创建c3p0配置时的引用。提高配置的灵活性

jdbc.driver=com.mysql.cj.jdbc.Driver
jdbc.url=jdbc:mysql://host/database?useUnicode=true&characterEncoding=utf-8&serverTimezone=GMT%2B8&useSSL=false
jdbc.username=root
jdbc.password=xxx

#指定连接池的初始化连接数
initialPollSize = 20

# 指定连接池中保留最大连接数
maxPoolSize = 100

# 指定连接池中保留最小连接数
minPoolSize = 10

# 最大空闲时间，60毫秒内未使用则链接被丢失，若0则永不丢失。default:0
maxIdleTime = 600

# 当连接池中的连接数耗尽的时候c3p0一次同时获取的连接数，default:3
acquireIncrement = 5

# jdbc的标准，用于控制数据源内加载的preparedStatements数量
maxStatements = 5

# 每60秒检查所有连接池中的空闲链接. default :8
idleConnectionTestPeriod = 60

3、resources目录下创建spring的xml文件

• 1、创建Bean 的自动扫描功能（annotation），让IOC容器统一管理base-package目录下的Bean

• 2、加载properties配置

• 3、配置c3p0链接池

• 4、配置jdbcTemplate 的Bean，注入dataSource

<?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.xsd
        http://www.springframework.org/schema/context
        https://www.springframework.org/schema/context/spring-context.xsd">

    <!--  自动扫描包，让指定包下的注解生效，由IOC容器统一管理  -->
    <context:component-scan base-package="com.luciano"/>

    <!--  加载properties配置，可以读取jdbc.properties配置文件中的数据  -->
    <context:property-placeholder location="jdbc.properties"/>

    <!--  配置c3p0数据源  -->
    <bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
        <property name="driverClass" value="${jdbc.driver}"/>
        <property name="jdbcUrl" value="${jdbc.url}"/>
        <property name="user" value="${jdbc.username}"/>
        <property name="password" value="${jdbc.password}"/>
        <property name="maxPoolSize" value="${maxPoolSize}"/>
    </bean>


    <!-- 配置jdbc模板对象，并注入一个数据源   -->
    <bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">
        <property name="dataSource" ref="dataSource"/>
    </bean>
</beans>

4、创建数据库对应的实体类和接口

• 1、在 src/main/java目录下创建对应的dao层以及po层

src.main.java.com.xxx.dao

src.main.java.com.xxx.pojo

• 2、在pojo Package中创建实体类，并创建有参、无参构造方法以及getter、setter等

这里直接使用@Data @AllArgsConstructor @NoArgsConstructor 自动构建

@Data
@AllArgsConstructor
@NoArgsConstructor
public class Account {
 private Integer account_id; //id
 private String account_name; // 账户名称
 private String account_type;  // 账户类型
 private double money; // 账户金额
 private String remark; // 账户备注
 private Date create_time;  // 创建时间
 private Date update_time;  // 更新时间
 private Integer user_id; // 用户外键
}

• 3、在 dao Package中创建接口

public interface IAccountDao{
     /**
     * 添加账户
     *
     * @param account
     * @return 受影响的行数
     */
    public int addAccount(Account account);
    /**
     * 添加账户，返回主键
     *
     * @param account
     * @return 主键
     */
    public int addAccountHasKey(Account account);
}

5、创建接口实现类

• 在dao Package中创建impl Package 创建接口实现类

dao.impl

这里使用annotation方式，将dao层来使用@Repository将类标识为Bean

为什么 @Repository 只能标注在 DAO 类上呢？

这是因为该注解的作用不只是将类识别为Bean，同时它还能将所标注的类中抛出的数据访问异常封装为 Spring 的数据访问异常类型。 Spring本身提供了一个丰富的并且是与具体的数据访问技术无关的数据访问异常结构，用于封装不同的持久层框架抛出的异常，使得异常独立于底层的框架。

@Resource用于依赖注入，从容器中自动获取bean

@Resource主要做依赖注入的，从容器中自动获取bean，和@Autowired用法相似，作用如下：

1、在启动Spring时，首先要启动容器

2、在启动Spring容器时，会默认寻找容器扫描范围内的可加载的bean，然后查找哪些bean上的属性和方法有@resource注解

3、找到@Resource注解后，判断其name属性是否为空，若为空，看Spring容器中的bean中的id与@Resource要注解的那个变量属性名是否相同，如相同，匹配成功；如不同，看spring容器中bean的id对应的类型是否与@Resource要注解的那个变量属性对应的类型是否相等，若相等，匹配成功，若不相等，匹配失败。

4、如果@Resource注解括号中的name属性不为空，看name的属性值和容器中的bean的id名是否相等，如相等，则匹配成功；如不相等，则匹配失败。

@Repository  //将类标识为Bean
public class AccountDaoImpl implements IAccountDao {

@Resource //依赖注入
private JdbcTemplate jdbcTemplate;

/**
 * 添加账户记录，返回受影响的行数
 *
 * @param account
 * @return 受影响的行数
 */
@Override
public int addAccount(Account account) {
    //定义sql
    String sql = "insert into account_bank (account_name,account_type,money,remark," +
            "create_time,update_time,user_id) values(?,?,?,?,now(),now(),?)";

    // 设置参数
    Object[] objects = {account.getAccount_name(), account.getAccount_type(), account.getMoney(),
            account.getRemark(), account.getUser_id()};
    int row = jdbcTemplate.update(sql, objects);
    return row;
}

/**
 * 添加账户记录，返回主键
 *
 * @param account
 * @return 主键
 */
@Override
public int addAccountHasKey(Account account) {
    //定义sql
    String sql = "insert into account_bank (account_name,account_type,money,remark," +
            "create_time,update_time,user_id) values(?,?,?,?,now(),now(),?)";
    // 定义KeyHolder对象， 获取记录的主键值
    KeyHolder keyHolder = new GeneratedKeyHolder();

    jdbcTemplate.update(connection -> {
        //预编译sql语句，并设置返回主键
        PreparedStatement ps = connection.prepareStatement(sql, Statement.RETURN_GENERATED_KEYS);
        // 设置参数
        ps.setString(1, account.getAccount_name());
        ps.setString(2, account.getAccount_type());
        ps.setDouble(3, account.getMoney());
        ps.setString(4, account.getRemark());
        ps.setInt(5, account.getUser_id());
        return ps;
    }, keyHolder);
    //得到返回的主键
    int key = keyHolder.getKey().intValue();
    return key;
}

6、创建测试类

• 1、在src/rest/java下创建一个Package用来测试

src.test.java.com.xxx.test

• 2、创建一个测试封装类，用于其他测试类继承

@RunWith(SpringJUnit4ClassRunner.class) //将测试运行在spring测试环境中

@ContextConfiguration(locations = {“classpath:spring.xml”}) //设置要加载的配置文件

---

// 测试封装类，其他的测试文件集成此类即可完成对jdbc的注入
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(locations = {"classpath:spring.xml"})
public class BaseJdbc {
}

• 3、创建测试类

@Test：在需要测试的方法上加入此注释器，用于识别测试类

public class SpringJdbcTest04 extends BaseJdbc {
    @Resource
    private JdbcTemplate jdbcTemplate;
    
    @Test
    public void testJdbc() {
        //curd
        String sql = "select count(1) from account_bank";
        Integer total = this.jdbcTemplate.queryForObject(sql, Integer.class);
        System.out.println("总记录数" + total);
    }

}

public class AccountAddTest extends BaseJdbc {
    @Resource
    private IAccountDao accountDao;

    /*
    添加账户记录，返回受影响行数
     */
    @Test
    public void testAddAccount() {
        //准备要添加的数据
        Account account = new Account(null, "账户3", "邮政银行", 8000.00,
                "奖金", null, null, 1);
        //调用对象中的添加方法
        int row = accountDao.addAccount(account);
        System.out.println("添加账户受影响的行数" + row);
    }

    /*
    添加账户记录，返回账户主键
     */
    @Test
    public void testAddAccountHasKey() {
        //准备要添加的数据
        Account account = new Account(null, "账户4", "中国银行", 8000.00,
                "年终奖", null, null, 2);
        //调用对象中的添加方法
        int key = accountDao.addAccountHasKey(account);
        System.out.println("主键："+key);
    }
}