JavaEE學習日誌(九十一): AOP管理轉賬事務，jdbcTemplate詳解

原創 隔叶听风 2020-05-05 04:18

JavaEE學習日誌持續更新----> 必看！JavaEE學習路線（文章總彙）

JavaEE學習日誌（九十一）

Spring

AOP管理轉賬事務

xml配置實現

AccountDaoImpl

package com.itheima.dao.impl;

import com.itheima.dao.AccountDao;
import com.itheima.domain.Account;
import com.itheima.utils.ConnectionUtil;
import org.apache.commons.dbutils.QueryRunner;
import org.apache.commons.dbutils.handlers.BeanHandler;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Repository;

import java.sql.SQLException;

@Repository
public class AccountDaoImpl implements AccountDao {
    @Autowired
    QueryRunner queryRunner;
    @Autowired
    ConnectionUtil connectionUtil;
    @Override
    public Account findByName(String name) {
        String sql = "select * from account where name = ?";
        try {
            return queryRunner.query(connectionUtil.getThreadConnection(),sql,new BeanHandler<Account>(Account.class),name);
        } catch (SQLException e) {
            e.printStackTrace();
        }
        return null;
    }

    @Override
    public void update(Account account) {
        String sql = "update account set money = ? where name = ?";
        try {
            queryRunner.update(connectionUtil.getThreadConnection(),sql,account.getMoney(),account.getName());
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }
}

AccountServiceImpl

package com.itheima.service.impl;

import com.itheima.dao.AccountDao;
import com.itheima.domain.Account;
import com.itheima.service.AccountService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

@Service
public class AccountServiceImpl implements AccountService {
    @Autowired
    AccountDao accountDao;
    @Override
    public void transfer(String fromName, String toName, Float money) {
        //查詢轉賬的賬戶
        Account fromAccount = accountDao.findByName(fromName);
        //查詢接收的賬戶
        Account toAccount = accountDao.findByName(toName);
        //開始轉賬
        fromAccount.setMoney(fromAccount.getMoney()-money);
        toAccount.setMoney(toAccount.getMoney()+money);
        //持久化到數據庫
        accountDao.update(fromAccount);
        accountDao.update(toAccount);
    }
}

TransactionManager作爲通知對象

package com.itheima.utils;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

import java.sql.SQLException;

/**
 * 事務管理器：是通知對象
 * @author 黑馬程序員
 * @Company http://www.ithiema.com *
 * @Version 1.0
 */
@Component
public class TransactionManager {

    @Autowired
    private ConnectionUtil connectionUtil;

    public void setConnectionUtil(ConnectionUtil connectionUtil) {
        this.connectionUtil = connectionUtil;
    }

    //開啓事務
    public void beginTransaction() {
        //從當前線程上獲取連接，實現開啓事務
        try {
            connectionUtil.getThreadConnection().setAutoCommit(false);
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }

    //提交事務
    public void commit() {
        try {
            connectionUtil.getThreadConnection().commit();
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }


    //回滾事務
    public void rollback() {
        try {
            connectionUtil.getThreadConnection().rollback();
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }

    //釋放連接
    public void release() {
        try {
            connectionUtil.getThreadConnection().setAutoCommit(true);
            //關閉連接（還回池中）
            connectionUtil.getThreadConnection().close();
            //解綁線程：把連接和線程解綁
            connectionUtil.remove();
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }
}

ConnectionUtil用於獲取連接

package com.itheima.utils;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

import javax.sql.DataSource;
import java.sql.Connection;
import java.sql.SQLException;

/**
 * 一個管理連接的工具類，用於實現連接和線程的綁定
 * @author 黑馬程序員
 * @Company http://www.ithiema.com
 * @Version 1.0
 */
@Component
public class ConnectionUtil {
    private ThreadLocal<Connection> tl = new ThreadLocal<Connection>();
    @Autowired
    private DataSource dataSource;
    public void setDataSource(DataSource dataSource) {
        this.dataSource = dataSource;
    }
    /**
     * 獲取當前線程上綁定的連接
     * @return
     */
    public Connection getThreadConnection() {
        try {
            //1.先看看線程上是否綁了
            Connection conn = tl.get();
            if(conn == null) {
                //2.從數據源中獲取一個連接
                conn = dataSource.getConnection();
                //3.和線程局部變量綁定
                tl.set(conn);
            }
            //4.返回線程上的連接
            return tl.get();
        } catch (SQLException e) {
            throw new RuntimeException(e);
        }
    }

    /**
     * 把連接和當前線程解綁
     */
    public void remove() {
        tl.remove();
    }
}

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: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/context http://www.springframework.org/schema/context/spring-context.xsd http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop.xsd">
    <!--開啓註解-->
    <context:component-scan base-package="com.itheima"></context:component-scan>

    <!--dao層需要注入qr-->
    <bean id = "queryRunner" class="org.apache.commons.dbutils.QueryRunner"></bean>
    <!--創建dataSource-->
    <bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
        <property name="driverClass" value="${jdbc.driver}"></property>
        <property name="jdbcUrl" value="${jdbc.url}"></property>
        <property name="user" value="${jdbc.username}"></property>
        <property name="password" value="${jdbc.password}"></property>
    </bean>
    <!--引入外部屬性文件-->
    <context:property-placeholder location="jdbc.properties"></context:property-placeholder>

    <!--使用aop解決事務問題
        事務管理器類：通知對象
    -->
    <aop:config>
        <!--切面-->
        <aop:aspect ref="transactionManager">
            <!--配置切入點-->
            <aop:pointcut id="pointcut" expression="execution(* com.itheima.service..*.*(..))"/>
            <!--配置通知-->
            <!--前置增強，開啓事務-->
            <aop:before method="beginTransaction" pointcut-ref="pointcut"></aop:before>
            <!--後置增強，提交事務-->
            <aop:after-returning method="commit" pointcut-ref="pointcut"></aop:after-returning>
            <!--異常增強，回滾事務-->
            <aop:after-throwing method="rollback" pointcut-ref="pointcut"></aop:after-throwing>
            <!--最終增強，釋放資源-->
            <aop:after method="release" pointcut-ref="pointcut"></aop:after>

        </aop:aspect>
    </aop:config>




</beans>

測試

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration("classpath:applicationContext.xml")
public class TestSpring {
    @Autowired
    AccountService accountService;
    @Test
    public void test(){
        accountService.transfer("aaa","ccc",20F);
    }
}

註解配置實現

xml中

<!--開啓自動代理註解-->
    <aop:aspectj-autoproxy></aop:aspectj-autoproxy>

在通知對象中配置註解

package com.itheima.utils;

import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Pointcut;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

import java.sql.SQLException;

/**
 * 事務管理器：是通知對象
 * @author 黑馬程序員
 * @Company http://www.ithiema.com *
 * @Version 1.0
 */
@Component
@Aspect
public class TransactionManager {

    @Autowired
    private ConnectionUtil connectionUtil;

    public void setConnectionUtil(ConnectionUtil connectionUtil) {
        this.connectionUtil = connectionUtil;
    }

    @Pointcut("execution(* com.itheima.service..*.*(..))")
    public void pointcut(){}
    /**
     * 環繞增強
     */
    @Around("pointcut()")
    public void around(ProceedingJoinPoint joinPoint){
        //執行原方法
        try {
            //前置增強
            beginTransaction();
            joinPoint.proceed();
            //後置增強
            commit();
        } catch (Throwable throwable) {
            //異常增強
            rollback();
            throwable.printStackTrace();
        } finally {
            //最終增強
            release();
        }
    }

    //開啓事務
    public void beginTransaction() {
        //從當前線程上獲取連接，實現開啓事務
        try {
            connectionUtil.getThreadConnection().setAutoCommit(false);
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }

    //提交事務
    public void commit() {
        try {
            connectionUtil.getThreadConnection().commit();
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }


    //回滾事務
    public void rollback() {
        try {
            connectionUtil.getThreadConnection().rollback();
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }

    //釋放連接
    public void release() {
        try {
            connectionUtil.getThreadConnection().setAutoCommit(true);
            //關閉連接（還回池中）
            connectionUtil.getThreadConnection().close();
            //解綁線程：把連接和線程解綁
            connectionUtil.remove();
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }
}

也可以不配置切入點，直接在通知的註解中寫上表達式

@Around("execution(* com.itheima.service..*.*(..))")

jdbcTemplate

三種數據源的配置

三種數據源：c3p0，dbcp，spring自帶的數據源

引入依賴：其中spring自帶的數據源裏包含了jdbcTemplate

<dependency>
            <groupId>c3p0</groupId>
            <artifactId>c3p0</artifactId>
            <version>0.9.1.2</version>
        </dependency>
        <!--dbcp數據源-->
        <dependency>
            <groupId>commons-dbcp</groupId>
            <artifactId>commons-dbcp</artifactId>
            <version>1.4</version>
        </dependency>
        <!--spring自帶數據源-->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-jdbc</artifactId>
            <version>5.0.2.RELEASE</version>
        </dependency>

配置三種數據源

<!--引入外部屬性文件-->
    <context:property-placeholder location="classpath:jdbc.properties"></context:property-placeholder>
    <!--配置c3p0數據源-->
    <bean id="c3p0DataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
        <property name="driverClass" value="${jdbc.driver}"></property>
        <property name="jdbcUrl" value="${jdbc.url}"></property>
        <property name="user" value="${jdbc.username}"></property>
        <property name="password" value="${jdbc.password}"></property>
    </bean>
    <!--配置dbcp-->
    <bean id="dbcpDataSource" class="org.apache.commons.dbcp.BasicDataSource">
        <property name="driverClassName" value="${jdbc.driver}"></property>
        <property name="url" value="${jdbc.url}"></property>
        <property name="username" value="${jdbc.username}"></property>
        <property name="password" value="${jdbc.password}"></property>
    </bean>
    <!--spring自帶的數據源-->
    <bean id="springDataSource" class="org.springframework.jdbc.datasource.DriverManagerDataSource">
        <property name="driverClassName" value="${jdbc.driver}"></property>
        <property name="url" value="${jdbc.url}"></property>
        <property name="username" value="${jdbc.username}"></property>
        <property name="password" value="${jdbc.password}"></property>
    </bean>

jdbcTemplate的查詢操作

一、查詢全部

  • queryForList(sql語句) 返回值是list集合，list集合中是map集合
  • query(sql語句，列與屬性的映射) 返回的是list集合，集合中是查詢的對象

創建列與屬性的映射類：結果集對象，每次都包含一行數據

package com.itheima.mapper;

import com.itheima.domain.Account;
import org.springframework.jdbc.core.RowMapper;

import java.sql.ResultSet;
import java.sql.SQLException;

public class AccountRowMapper implements RowMapper<Account> {
    /**
     *
     * @param resultSet 結果集對象，只包含了一行數據
     * @param i
     * @return
     * @throws SQLException
     */
    @Override
    public Account mapRow(ResultSet resultSet, int i) throws SQLException {
        Account account = new Account();
        int id = resultSet.getInt("id");
        account.setId(id);
        account.setName(resultSet.getString("name"));
        account.setMoney(resultSet.getFloat("money"));
        return account;
    }
}


@Test
    public void findAll(){
        String sql = "select * from account";
        //queryForList方法返回值是list集合，list集合中是map集合
//        List<Map<String, Object>> accountList = jdbcTemplate.queryForList(sql);
//        for (Map<String, Object> map : accountList) {
//            System.out.println(map);
//        }

        //query
        List<Account> list = jdbcTemplate.query(sql, new AccountRowMapper());
        for (Account account : list) {
            System.out.println(account);
        }

    }

二、根據id查詢

  • query(sql語句，列與屬性的映射，參數) 和上述基本一致，返回一個list集合
  • queryForObject(sql語句，列與屬性的映射，參數) 查詢一個對象
  • queryForObject(sql語句，參數列表（必須是數組類型），jdbcTemplate自帶映射：必須保證屬性和列名一致) 這個方法只能當列與屬性名相同時使用，也是返回一個對象，不建議使用
@Test
    public void findById(){
        String sql = "select * from account where id = ?";
//        List<Account> list = jdbcTemplate.query(sql, new AccountRowMapper(),1);

        //queryForObject(sql語句，列與屬性的映射，參數)查詢一個對象
//        Account account = jdbcTemplate.queryForObject(sql, new AccountRowMapper(), 1);
//        System.out.println(account);
        //queryForObject(sql語句，參數列表（必須是數組類型），jdbcTemplate自帶映射：必須保證屬性和列名一致)
        Account account = jdbcTemplate.queryForObject(sql, new Object[]{1}, new BeanPropertyRowMapper<>(Account.class));
        System.out.println(account);

    }

三、聚合函數

  • queryForObject(sql, 返回值類型)
@Test
    public void totalCount() {
        String sql = "select count(*) from account";
        //queryForObject(sql語句，返回值類型)
        Integer integer = jdbcTemplate.queryForObject(sql, Integer.class);
        System.out.println(integer);
    }

jdbcTemplate的增刪改操作

和dbUtils一樣，update方法

@Test
    public void save(){
        String sql = "insert into account values(null,?,?)";
        jdbcTemplate.update(sql,"ddd",500);

    }

    @Test
    public void update(){
        String sql = "update account set money = ? , name = ? where id = ?";
        jdbcTemplate.update(sql,1000F,"eee",5);
    }

    @Test
    public void del() {
        String sql = "delete from account where id = ?";
        jdbcTemplate.update(sql,5);
    }

jdbcTemplate在dao層中兩種使用方法

第一種：和上述一樣，使用spring相關技術即可

第二種：

  1. 在dao層的實現類種繼承接口JdbcDaoSupport
public class AccountDaoImpl2 extends JdbcDaoSupport implements AccountDao
  1. 所有的dao對象需要在xml中創建，並通過set方法注入數據源對象
<!--創建dao層對象-->
    <bean id="accountDao" class="com.itheima.dao.impl.AccountDaoImpl2">
        <!--通過set方法注入數據源-->
        <property name="dataSource" ref="springDataSource"></property>
    </bean>
  1. 使用getJdbcTemplate() 獲取jdbcTemplate
@Override
    public List<Account> findAll() {
        String sql = "select * from account";
        List<Account> accountList = getJdbcTemplate().query(sql, new AccountRowMapper());
        return accountList;
    }
發表評論
所有評論
還沒有人評論，想成為第一個評論的人麼? 請在上方評論欄輸入並且點擊發布.
相關文章

Spring項目中使用NIO並行調用http接口指南

1-背景 後臺BFF層服務爲了SEO，涉及大量對底層數據的聚合，如果按照過程化編程，串行執行請求數據再聚合會造成很高的延遲，因此我們往往大量使用多線程技術並行化多個查詢，來減少單個請求的響應時間。 多線程一定程度上也能達成通過並行化提升

原創 2024-05-23 11:10:25

Spring優雅使用log4j2日誌

1-前言 Spring框架本身提供了對日誌的集成，對logback的支持非常好，但是對log4j和log4j2的支持就沒那麼好。 在同步打印日誌的場景下logback擁有最高的日誌吞吐量《Logback Throughput Benchma

原創 2024-05-22 23:12:10

爲什麼不推薦在Spring Boot中使用@Value加載配置

@Value註解相信很多Spring Boot的開發者都已經有接觸了，通過使用該註解，我們可以快速的把配置信息加載到Spring的Bean中。 比如下面這樣，就可以輕鬆的把配置文件中key爲com.didispace.title配置信息加載

原創 2024-05-21 21:46:20

系統國際化之多語言解決方案| 京東物流技術團隊

1. 背景 隨着京東各業務板塊國際化進程的不斷推進，諸多業務已經融入了多元文化中，一個一體化的多語言系統解決方案成爲各個技術團隊討論的焦點。國際物流系統憑藉在國際化領域多年的經驗，特別是在系統多語言處理上長期的經驗積累，總結了一套標準

原創 2024-05-17 23:56:46

「Java開發指南」如何用MyEclipse搭建GWT 2.1和Spring？（二）

本教程將指導您如何生成一個可運行的Google Web Toolkit (GWT) 2.1和Spring應用程序，該應用程序爲域模型實現了CRUD應用程序模式。在本教程中，您將學習如何： 安裝Google Eclipse插件 爲GWT配置

原創 2024-05-17 12:21:26

Spring boot自動裝配實現原理

自動裝配原理分析 條件註冊機制 spring-context模塊中有兩個組件：Condition接口和@Conditional註解，在@Conditional註解中可以指定一組Condition實現， 通常@Conditional是和@Co

原創 2024-05-16 23:48:07

Spring @EnableXxx註解的使用理解

@EnableXxx註解 Spring有很多@EnableXxx這種形式的註解，類似於可以一鍵打開某項功能，相當於暴露給用戶的一種便捷的配置API，例如 @EnableAsync 激活異步執行能力，@EnableTransactionMan

原創 2024-05-16 23:48:06

Spring cloud bootstrap context機制

Bootstrap Application Context Spring cloud程序在啓動階段，如果開啓了bootstrap啓動過程，則啓動時首先會創建一個bootstrap context，這個容器是項目主容器的父容器，它們共享一個E

原創 2024-05-15 11:50:16

Spring cloud gateway入門

微服務Gateway 微服務網關部署在前端Nginx網關和後端微服務之間，Nginx一般充當流量網關，而微服務網關屬於一種業務型 網關，微服務網關層爲後端的微服務羣組提供統一的接入地址，其核心功能是統一做服務路由，在路由基礎上還 可以實現一

原創 2024-05-15 11:50:15

Spring cloud 服務註冊發現

服務發現 在Spring cloud中，要注意區別服務和服務實例，這是兩個概念，一個微服務單元可以部署多個節點， 每個節點即一個服務實例，Spring cloud默認通過 spring.application.name 配置項來標識一個微服

原創 2024-05-15 11:50:14

Spring 按條件裝配使用方法

條件註冊 Spring 4.0 引入條件註冊機制，暴露給用戶的API是@Conditional和Condition接口，把@Conditional聲明在一個 @Component類上，並接受一組條件（Condition實現），容器初始化期間

原創 2024-05-15 11:50:12

Spring知識點詳解（源碼筆記+思維導圖），AOP和IOC

寫在前面 由於Spring家族的東西很多，一次性寫完也不太現實。所以這一次先更新Spring【最核心】的知識點：AOP和IOC   無論是入門還是面試，理解AOP和IOC都是非常重要的。在面試的時候，我沒怎麼被問過MyBatis/Hib

osc_r0irdqn7 2024-05-14 01:47:38

從XML配置角度理解Spring AOP

本文分享自華爲雲社區《Spring高手之路18——從XML配置角度理解Spring AOP》，作者： 磚業洋__。 1. Spring AOP與動態代理 1.1 Spring AOP和動態代理的關係 Spring AOP使用動態代理作爲

原創 2024-05-13 11:31:09

Spring AOP 中被代理的對象一定是單例嗎？

今天我們來思考這樣一個問題：在 Spring AOP 中，被代理的對象是單例的嗎？當我們每次獲取到代理對象的時候，都會重新獲取一個新的被代理對象嗎？還是被代理的對象始終是同一個？ 爲什麼要思考這個問題，因爲在松哥接下來要講的 @Scope

原創 2024-05-13 02:20:48

Spring Boot3，啓動時間縮短 10 倍！

前面松哥寫了一篇文章和大家聊了 Spring6 中引入的新玩意 AOT（見Spring Boot3 新玩法，AOT 優化！）。 文章發出來之後，有小夥伴問松哥有沒有做性能比較，老實說，這個給落下了，所以今天再來一篇文章，和小夥伴們梳理比較小

原創 2024-05-13 02:20:47