从“0”开始，自学笔记（8）spring框架——JDBC与事务

最新推荐文章于 2024-06-15 20:07:11 发布

每天都在进步的小萌新

最新推荐文章于 2024-06-15 20:07:11 发布

阅读量102

点赞数 1

文章标签： spring java idea jdbc

本文链接：https://blog.csdn.net/a9b321/article/details/119207745

版权

1、什么是jdbc

JDBC 是一种用于执行SQL语句的Java API，可以为多种关系数据库提供统一访问，它由一组用Java语言编写的类和接口组成。spring框架提供了基于JDBC的数据访问功能。

2、环境搭建

pom.xml添加依赖

<!--    spring框架坐标依赖-->
    <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>5.1.37</version>
    </dependency>
<!--    c3p0链接池-->
    <dependency>
      <groupId>com.mchange</groupId>
      <artifactId>c3p0</artifactId>
      <version>0.9.5.5</version>
    </dependency>

资源目录下新建jdbc.properties文件

（必写）

#驱动名
jdbc.driver=com.mysql.jdbc.Driver
#数据库连接
jdbc.url=jdbc:mysql://localhost:（端口号）/（数据库名）?\
  useUnicode=true&characterEncoding=utf8&serverTimezone=GMT%2B8&useSSL=false
#数据用户名
jdbc.user=（用户名）
#数据库用户密码
jdbc.password=（密码）

（不必要）

#指定连接池的初始化连接数。取值应在minPoolSize 与maxPoolSize 之间. Default:3
initialPoolSize=20
#指定连接池中保留的最大连接数. Default:15
maxPoolSize=100
#指定连接池中保留的最小连接数
minPoolSize=10
#最大空闲时间，60秒内未使用则连接被丢弃。若为0则永不丢弃。Default:0
maxIdleTime=600
#当连接池中的连接耗尽的时候c3pθ-次同时获取的连接数. Default:3
acquireIncrement=5
# JDBC的标准，用以控制数据源内加载的PreparedStatements数量。
maxStatements=5
#每60秒检查所有连接池中的空闲连接. Default:0
idleConnectionTestPeriod=60

资源目录下xml配置

xmlns:context="http://www.springframework.org/schema/context"
xmlns:aop="http://www.springframework.org/schema/aop"
xmlns:tx="http://www.springframework.org/schema/tx"

http://www.springframework.org/schema/context
https://www.springframework.org/schema/context/spring-context.xsd
http://www.springframework.org/schema/aop
https://www.springframework.org/schema/aop/spring-aop.xsd
http://www.springframework.org/schema/tx
https://www.springframework.org/schema/tx/spring-tx.xsd

<!--    spring注解自动开启-->
    <context:component-scan base-package="com.wode"/>
<!--    aop-->
    <aop:aspectj-autoproxy/>
<!--    加载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.user}"/>
        <property name="password" value="${jdbc.password}"/>
    </bean>
<!--    模板类-->
    <bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">
        <property name="dataSource" ref="dataSource"/>
    </bean>

3、操作数据库（更新）

3.1、查询

ApplicationContext ac = new ClassPathXmlApplicationContext("spring.xml");
JdbcTemplate jdbcTemplate = (JdbcTemplate) ac.getBean("jdbcTemplate");

String sql = "select user from user where id=?";
String total = jdbcTemplate.queryForObject(sql,String.class,1);
System.out.println(total);

queryForObject（）用法

1、返回基本类型

基本类型名 i = jdbcTemplate.queryForObject

(sql,（基本类型名）.class,（sql中"？"的值有多个"？"就依次输入多个）);

2、返回对象，需要使用RowMapper 接口实现传参操作，然后返回一个对象

String sql = "select * from user where id=?";

RowMapper rowMapper = new RowMapper() {
    @Override
    public Object mapRow(ResultSet resultSet, int i) throws SQLException {
        User user = new User();
        user.setUser(resultSet.getString("user"));
        user.setPassword(resultSet.getString("password"));
        user.setAge(resultSet.getInt("age"));
        user.setId(resultSet.getInt("id"));
        return user;
    }
};
User u = (User) jdbcTemplate.queryForObject(sql,rowMapper,1);

3.2、update:不会从数据库中得到值，默认返回一个Integer类型，表示操作的行数

3.2.1、添加

String sql = "insert into user (user,password) values (?,?)";
Integer integer = jdbcTemplate.update(sql,"user","password");

3.2.2、修改

String sql = "update user set user=? , password =? , age =? where id=?";
Integer integer = jdbcTemplate.update(sql,"user","password",1,1);

3.2.3、删除

String sql = "delete from user where id=?";
Integer integer = jdbcTemplate.update(sql,1);

4、什么是事务

事务是应用程序中一系列严密的操作，所有操作必须成功完成，否则在每个操作中所作的所有更改都会被撤消。

事务面向的是切面。

4.1、事务的特性（ACID）

1 、原子性
事务是数据库的逻辑工作单位，事务中包含的各操作要么都做，要么都不做
2 、一致性
事务执行前后，数据库中数据保持一致性状态。
3 、隔离性
事务与事务之间的执行应当相互隔离，互不干扰。通过隔离级别加以限制：

1. READ _UNCOMMITTED (读未提交)

隔离级别最低的一种事务级别。在这种隔离级别下，会引发脏读、不可重复读和幻读。

2. READ_ COMMITTED (读已提交)

读到的都是别人提交后的值。这种隔离级别下，会引发不可重复读和幻读,但避免了脏读。

3. REPEATABLE_ READ (可重复读)

这种隔离级别下，会引发幻读,但避免了脏读.不可重复读。

4. SERIALIZABLE (串行化)

最严格的隔离级别。在Serializable隔离级别下，所有事务按照次序依次执行。脏读、不可重复读、幻读都不会出现。

4 、持续性
也称永久性，指一个事务一旦提交，它对数据库中的数据的改变就应该是永久性的。接下来的其它操作或故障不应该对其执行结果有任何影响。

4.2、实现方法

xml配置方法

propagation：不必须，表示事务传播行为，增删改操作时使用，默认REQUIRED

isolation：不必须，表示事务隔离级别，默认值DEFAULT。

timeout：不必须，表示事务超时时间，默认值-1（永不超时）

read-only：不必须，表示只读，查询时使用，默认false（不只读）

rollback-for：不必须，表示将被回滚的Exception(s);逗号隔开

no-rollback-for：不必须，表示不被回滚的Exception(s);逗号隔开

<bean id="txManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
    
    <property name="dataSource" ref="dataSource"/>
</bean>


<tx:advice id="txAdvice" transaction-manager="txManager">
    <tx:attributes>

        <tx:method name="（方法名，可以用通配符*）" propagation="REQUIRED" />
    </tx:attributes>
</tx:advice>


<aop:config>
    <aop:pointcut id="cut" expression="execution(* com.xxxx.service..*(..))"/>

    <aop:advisor advice-ref="txAdvice" pointcut-ref="cut"/>
</aop:config>

注释方法

@Transactional(propagation = Propagation.REQUIRED)
public void *(..){
}

事务传播行为

        REQUIRED：如果有事务，加入，没有就新建一个事务

        NOT_SUPPORTED：容器不开启事务

        REQUIRED_NEW：创建新的事务，老的事务挂起，执行完新的再执行老的

        MANDATORY：必须在已有事务中执行，否则异常

        NEVER：必须在没有的事务中执行，否则异常

        SUPPORTS：如果其他bean调用这个方法,在其他bean 中声明事务,那就用事务.如果其他bean没有声明事务,那就不用事务.

       NESTED：支持当前事务，如果当前事务存在，则执行-一个嵌套事务，如果当前没有事务，就新建一个事务。

每天都在进步的小萌新

关注

1
点赞
踩
0

收藏

觉得还不错? 一键收藏
3
评论
从“0”开始，自学笔记（8）spring框架——JDBC与事务

1、什么是jdbcJDBC 是一种用于执行SQL语句的Java API，可以为多种关系数据库提供统一访问，它由一组用Java语言编写的类和接口组成。spring框架提供了基于JDBC的数据访问功能。2、环境搭建pom.xml添加依赖 <dependency> <groupId>org.springframework</groupId> <artifact
复制链接

扫一扫