Spring-JDBC

Posted 2022-11-22 Vodka~

tags:

篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了Spring-JDBC相关的知识，希望对你有一定的参考价值。

pom.xml:

<?xml version="1.0" encoding="UTF-8"?>

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
  <modelVersion>4.0.0</modelVersion>

  <groupId>org.example</groupId>
  <artifactId>AutoInsert</artifactId>
  <version>1.0-SNAPSHOT</version>

  <name>AutoInsert</name>
  <!-- FIXME change it to the project's website -->
  <url>http://www.example.com</url>

  <properties>
    <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    <maven.compiler.source>1.8</maven.compiler.source>
    <maven.compiler.target>1.8</maven.compiler.target>
  </properties>

  <dependencies>
    <dependency>
      <groupId>junit</groupId>
      <artifactId>junit</artifactId>
      <version>4.12</version>
      <scope>test</scope>
    </dependency>

<!--    添加spring的配置环境-->
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-context</artifactId>
      <version> 5.3.9</version>
    </dependency>
<!--注解相关依赖-->
    <dependency>
      <groupId>javax.annotation</groupId>
      <artifactId>javax.annotation-api</artifactId>
      <version> 1.3.2</version>
    </dependency>
<!--  cglib 依赖 -->
      <dependency>
          <groupId>cglib</groupId>
          <artifactId>cglib</artifactId>
          <version>2.2.2</version>
      </dependency>
<!-- Spring AOP-->
    <dependency>
      <groupId>org.aspectj</groupId>
      <artifactId>aspectjweaver</artifactId>
      <version>1.8.9</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.25</version>
         </dependency>

<!--    c3p0 连接池 -->
         <dependency>
             <groupId>com.mchange</groupId>
             <artifactId>c3p0</artifactId>
             <version>0.9.5.5</version>
         </dependency>
  </dependencies>


</project>

二，数据库信息:

#驱动名
jdbc.driver=com.mysql.jdbc.Driver
#数据库连接
jdbc.url=jdbc:mysql://localhost:3306/hotel?useUnicode=true&characterEncoding=utf8&serverTimezone=GMT%2B8&useSSL=false
#数据库用户名称
jdbc.user=vodka
#数据库密码
jdbc.password=XXXXXXXXX

三，配置数据源：
- 由于建立数据库连接是一种耗费资源的行为，所以通过连接池预先同数据库建立一些连接，放在内存中，应用程序需要时，申请即可，用完再释放。
常用连接池（二选一即可）：
1.DBCP（DataBase connection pool），数据库连接池，apache的一个java连接池项目，也是 tomcat 使用的连接池组件，单独使用dbcp需要两个包： commons-dbcp.jar , commons.jar dbcp ，缺少自动回收空闲连接的功能。
2.c3p0 ：一个开源的JDBC连接池，实现了数据源，支持 JDBC3 规范和 JDBC2的标准扩展，目前使用它的开源项目有 Hibernate ， 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"
       xmlns:aop="http://www.springframework.org/schema/aop"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
       http://www.springframework.org/schema/beans/spring-beans.xsd
       http://www.springframework.org/schema/aop
       http://www.springframework.org/schema/aop/spring-aop.xsd
       http://www.springframework.org/schema/context
       http://www.springframework.org/schema/context/spring-context.xsd">

    <!--      设置spring自动化扫描注解范围  -->
    <context:component-scan base-package="com.vodka" />

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

    <!--       c3p0连接池配置-->
    <bean id="c3p0" class="com.mchange.v2.c3p0.ComboPooledDataSource">
        <!--              property标签的value属性对应的是jdbc.properties的相应属性（自定义配置文件）-->
        <property name="driverClass" value="$jdbc.driver"/>
        <property name="jdbcUrl" value="$jdbc.url"/>
        <property name="user" value="$jdbc.user"/>
        <property name="password" value="$jdbc.password"/>
    </bean>

    <!--模板类配置,Spring 把JDBC中重复的操作建立成了一个模板类: org.springframework.jdbc.core.jdbcTemplate-->
    <!--       配置实例，并注入一个c3p0类型的数据源连接池 -->
    <bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">
        <property name="dataSource" ref="c3p0"/>
    </bean>
</beans>

    public static void main(String[] args) 
        ApplicationContext applicationContext = new ClassPathXmlApplicationContext("AutoInsert.xml");
        //获取模板类
        JdbcTemplate jdbcTemplate = (JdbcTemplate) applicationContext.getBean("jdbcTemplate");
        //crud操作
        String Query = "Select count(*) from AccountTest";
        String QueryTwo = "Select count(1) from AccountTest where UserId = ? ";
        //执行操作
        Integer num = jdbcTemplate.queryForObject(Query,Integer.class);
        Integer numTwo = jdbcTemplate.queryForObject(QueryTwo,Integer.class,688);
        System.out.println("数据库有  " + num + " 行.");
        System.out.println("UserId等于688的有  " + numTwo + " 行.");

四，当使用注解的方式配置Spring测试环境时，需添加依赖

<!--Spring Test 版本-->
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-test</artifactId>
      <version>4.3.2.RELEASE</version>
    </dependency>

！！！ 这样做的目的是减少冗余代码，比如，进行单元测试时，每个单元测试都需要获取配置文件和测试环境，用注解实现时，就能避免该问题，还可以设计一个公共测试类，有新的测试类时，继承使用即可，这样，不用每个测试类都写一遍注解

@RunWith(SpringJUnit4ClassRunner.class)  //运行器,设置为Spring测试环境
@ContextConfiguration( locations = "classpath:AutoInsert.xml")  //要解析加载的配置文件
public class jdbcTest 

    @Resource
    private JdbcTemplate jdbcTemplate;

            @Test
            public  void TestOne()
                String sql = "select count(*) from AccountTest";
                Integer num = jdbcTemplate.queryForObject(sql,Integer.class);
                System.out.println("数据库有 " + num +" 列" );
            

            @Test
            public  void TestTwo()
                String sql = "select count(*) from AccountTest where UserId = ?";
                Integer num = jdbcTemplate.queryForObject(sql,Integer.class,688);
                System.out.println("用户ID为 688 的有 " + num + " 列");

curd测试:
1.配置方式一（代码配置数据源）:

<!--  HiKariCP数据库连接池-->
    <dependency>
      <groupId>com.zaxxer</groupId>
      <artifactId>HikariCP</artifactId>
      <version>3.4.2</version>
    </dependency>
<!--    HSQLDB是一款Java内置的数据库，非常适合在用于快速的测试和演示的Java程序中-->
    <dependency>
      <groupId>org.hsqldb</groupId>
      <artifactId>hsqldb</artifactId>
      <version>2.5.0</version>
    </dependency>

@ContextConfiguration
@ComponentScan
@PropertySource("jdbc.properties")
public class AppConfig 
     @Value("$jdbc.url")
    String JdbcUrl;

    @Value("$jdbc.username")
    String JdbcUserName;

    @Value("$jdbc.password")
    String JdbcPassWord;

//    Spring的@Bean注解用于告诉方法，产生一个Bean对象，然后这个Bean对象交给Spring管理。
    @Bean
    DataSource createDataSource()
        HikariConfig config = new HikariConfig();
        config.setJdbcUrl(JdbcUrl);
        config.setUsername(JdbcUserName);
        config.setPassword(JdbcPassWord);
        config.addDataSourceProperty("autoCommit", "true");
        config.addDataSourceProperty("connectionTimeout", "5");
        config.addDataSourceProperty("idleTimeout", "60");
        return new HikariDataSource(config);
    

    @Bean
    JdbcTemplate createJdbcTemplate(@Autowired DataSource dataSource)
        return new JdbcTemplate(dataSource);

CRUD操作:

1.AccountDaoInterface
/*
 *    账户模块接口规范：
 *       1.添加账户：
 *            -添加用户记录，返回行数
 *            -添加记录，返回主键
 *            -批量添加账户记录，返回受影响行数
 *       2.修改账户：
 *            -修改用户记录，返回行数
 *            -批量修改账户记录，返回受影响行数
 *       3.删除账户：
 *            -删除用户记录，返回行数
 *            -批量删除账户记录，返回受影响行数
 *       4.查询账户：
 *            -查询指定用户的账户的总记录数，返回总数
 *            -查询指定账户详情，返回账户对象
 *            -多条件查询指定用户的列表，返回账户集合
 *
 *
 * */
public interface AccountDaoInterface 
    public  int AddAccount(AccountInfo accountInfo);

    public  int AddAccountReturnKey(AccountInfo accountInfo);

    public int AddBatchAccounts(List<AccountInfo> AccountInfoList);

    public  int ModifyAccount(AccountInfo accountInfo);

    public  int ModifyBatchAddAccount(List<AccountInfo> AccountInfoList);

    public AccountInfo QueryAccountByUserId(int UserId);

    public int QueryAllAccount();

    public AccountInfo QueryAccountByAccountId(int AccountId);

    public List<AccountInfo> QueryByDifferentCondition(int UserId,int AccountId,String AccountName,String AccountType ,String CreatTime);

    public  List<AccountInfo> FuzzyQuery(int UserId);

    public  int DeleteAccountByAccountId(int AccountId);

    public  int DeleteAccountByUserId(int UserId);

    public int DeleteBatchAccounts(Integer [] Ids);










2.AccountImp
@Repository
public class AccountImp implements AccountDaoInterface 

    @Autowired
    private JdbcTemplate jdbcTemplate;

    @Autowired
    private TimeUtil timeUtil;

    @Override
    public int AddAccount(AccountInfo AI) 
        AI.setCreatTime(timeUtil.GetNow());
        AI.setUpdateTime(timeUtil.GetNow());
        String sql = "insert into accounttest(UserId,AccountName,AccountType,Money,Remark,CreatTime,UpdateTime)values(?,?,?,?,?,?,?)";
        Object [] args = AI.getUserId(),AI.getAccountName(),AI.getAccountType(),AI.getMoney(),AI.getRemark(),AI.getCreatTime(),AI.getUpdateTime();
        int num =  jdbcTemplate.update(sql,args);
        System.out.println("影响: " + num + " 行");
        return num;
    

    @Override
    public int AddAccountReturnKey(AccountInfo AI) 
        AI.setCreatTime(timeUtil.GetNow());
        AI.setUpdateTime(timeUtil.GetNow());
        String sql = "insert into accounttest(UserId,AccountName,AccountType,Money,Remark,CreatTime,UpdateTime)values(?,?,?,?,?,?,?)";
        KeyHolder keyHolder = new GeneratedKeyHolder();  //用于接收主键
        //使用回调函数，从而接收主键
         jdbcTemplate.update(connection -> 
            //预编译sql语句
            PreparedStatement ps = connection.prepareStatement(sql, Statement.RETURN_GENERATED_KEYS);
            //设置参数
             ps.setInt(1,AI.getUserId());
             ps.setString(2,AI.getAccountName());
             ps.setString(3,AI.getAccountType());
             ps.setDouble(4, AI.getMoney());
             ps.setString(5, AI.getRemark());
             ps.setTimestamp(6, AI.getCreatTime());
             ps.setTimestamp(7, AI.getUpdateTime()Spring-JDBC
 Spring-JDBC
 CDI 中的 Spring-JDBC 等价物是啥？
 Spring-JDBC模板-事务
 在 spring-jdbc 中使用“where in”
 Spring-JDBC依赖