Spring框架学习第三天

最新推荐文章于 2022-02-13 17:53:20 发布
最新推荐文章于 2022-02-13 17:53:20 发布
阅读量175 收藏
点赞数
分类专栏： Spring框架学习 文章标签： spring java mybatis aop jdbc
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43616750/article/details/106451285
版权

转账案例基础

转账基础功能

public interface AccountDao {

    //转出
    void outUser(String outUser, Double money);

    //转入
    void inUser(String inUser, Double money);
}

@Repository
public class AccountDaoImpl implements AccountDao {

    //依赖queryRunner
    @Autowired
    private QueryRunner queryRunner;

    @Override
    public void outUser(String outUser, Double money) {

        String sql = "update account set money=money - ? where name = ?";
        //执行sql
        try {
            queryRunner.update(sql, money, outUser);
        } catch (SQLException e) {
            e.printStackTrace();
        }

    }

    @Override
    public void inUser(String inUser, Double money) {
        try {
            // 1.编写sql
            String sql = "update account set money = money + ?  where name = ?";
            // 2.执行sql
            queryRunner.update(sql, money, inUser);
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }
}

public interface AccountService {
    //转账
    void transfer(String outUser, String inUser, Double money);

}

@Service
public class AccountServiceImpl implements AccountService {

    //依赖注入accountDao
    @Autowired
    private AccountDao accountDao;


    @Override
    public void transfer(String outUser, String inUser, Double money) {
        //业务代码
        //转出

        accountDao.outUser(outUser, money);
        //转入

        accountDao.inUser(inUser, money);
   

@RunWith(SpringRunner.class)
@ContextConfiguration({"classpath:applicationContext.xml"})
public class AccountTest {

    @Autowired
    private AccountService accountService;

    //测试转账案例
    @Test
    public void test01() throws Exception {
        accountService.transfer("tom", "jerry", 100d);
    }
}

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:context="http://www.springframework.org/schema/context"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       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">



    <!--开启组件扫描-->
    <context:component-scan base-package="cn.itcast"></context:component-scan>
    <!--加载第三方配置文件-->
    <context:property-placeholder location="classpath:jdbc.properties"></context:property-placeholder>

    <!--druid连接交给ioc容器-->
    <bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource">
        <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>

    <!--queryRunner交给ioc容器-->
    <bean id="queryRunner" class="org.apache.commons.dbutils.QueryRunner">
        <constructor-arg name="ds" ref="dataSource"></constructor-arg>
    </bean>

</beans>

事务控制

上述方法存在问题的解决方案：
将service方法的多个dao层代码，看做一个事务，要么都成功，要么都失败！！！！

修改AccountService

@Service
public class AccountServiceImpl implements AccountService {

    //依赖注入accountDao
    @Autowired
    private AccountDao accountDao;
    //依赖dataSource
    @Autowired
    private DataSource dataSource;


    @Override
    public void transfer(String outUser, String inUser, Double money) {
        Connection connection = null;

        //获取conn手动控制事务
        try {
            connection = dataSource.getConnection();
            connection.setAutoCommit(false);
            //业务代码
            //转出

            accountDao.outUser(connection,outUser, money);

            //机器故障

            int i = 1 / 0;

            //转入
            accountDao.inUser(connection,inUser, money);

            //提交事务

            connection.commit();
        } catch (Exception e) {
            e.printStackTrace();
            try {
                //进行事务回滚
                connection.rollback();
            } catch (SQLException e1) {
                e1.printStackTrace();
            }
        } finally {
            // 释放资源
            try {
                // 再改为自动提交
                connection.setAutoCommit(true);

                connection.close();
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }

    }
}

修改AccountDao

@Repository
public class AccountDaoImpl implements AccountDao {

    //依赖queryRunner
    @Autowired
    private QueryRunner queryRunner;

    @Override
    public void outUser(Connection connection, String outUser, Double money) {
        try {
            String sql = "update account set money=money - ? where name = ?";
            //执行sql（使用service连接对象）
            queryRunner.update(connection, sql, money, outUser);
        } catch (SQLException e) {
            e.printStackTrace();
        }

    }

    @Override
    public void inUser(Connection connection,String inUser, Double money) {
        try {
            // 1.编写sql
            String sql = "update account set money = money + ?  where name = ?";
            // 2.执行sql（使用service连接对象）
            queryRunner.update(connection,sql, money, inUser);
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }
   }

问题：我们不应该将service的conn对象传递到dao层，这种方式，就产生了dao层与service的耦合性问题

ThreadLocal

ThreadLocal是一个线程的局部变量

@Component//交给ioc容器
public class ConnectionUtils {

    @Autowired
    private DataSource dataSource;

    //储物柜，线程隔离
    private static final ThreadLocal<Connection> tl = new ThreadLocal<Connection>();

    //从当前线程内绑定并获取conn对象
    public Connection getThreadConnection() {
        Connection connection = tl.get();
        if (connection == null) {
            try {
                connection = dataSource.getConnection();
                tl.set(connection);
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }
        return connection;
    }

    //移出当前线程的conn对象
    public void removeThreadConnection() {
        tl.remove();
    }


}

@Service
public class AccountServiceImpl implements AccountService {

    //依赖注入accountDao
    @Autowired
    private AccountDao accountDao;

    依赖dataSource
    //@Autowired
    //private DataSource dataSource;

    @Autowired
    private ConnectionUtils connectionUtils;


    @Override
    public void transfer(String outUser, String inUser, Double money) {
        Connection connection = null;

        //获取conn手动控制事务
        try {
            //connection = dataSource.getConnection();
            connection = connectionUtils.getThreadConnection();
            connection.setAutoCommit(false);
            //业务代码
            //转出

            accountDao.outUser(outUser, money);

            //机器故障

            int i = 1 / 0;

            //转入
            accountDao.inUser(inUser, money);

            //提交事务

            connection.commit();
        } catch (Exception e) {
            e.printStackTrace();
            try {
                //进行事务回滚
                connection.rollback();
            } catch (SQLException e1) {
                e1.printStackTrace();
            }
        } finally {
            // 释放资源
            try {
                // 再改为自动提交
                connection.setAutoCommit(true);

                connection.close();
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }

    }
}

@Repository
public class AccountDaoImpl implements AccountDao {

    //依赖queryRunner
    @Autowired
    private QueryRunner queryRunner;
    @Autowired
    private ConnectionUtils connectionUtils;

    @Override
    public void outUser(String outUser, Double money) {
        try {
            String sql = "update account set money=money - ? where name = ?";
            //获取当前线程内的conn
            final Connection threadConnection = connectionUtils.getThreadConnection();
            //执行sql（使用service连接对象）
            queryRunner.update(threadConnection, sql, money, outUser);
        } catch (SQLException e) {
            e.printStackTrace();
        }

    }

    @Override
    public void inUser( String inUser, Double money) {
        try {
            // 1.编写sql
            String sql = "update account set money = money + ?  where name = ?";
            // 获取当前线程内的 conn
            Connection threadConnection = connectionUtils.getThreadConnection();
            // 2.执行sql（使用service连接对象）

            queryRunner.update(threadConnection, sql, money, inUser);
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }
}

问题：在企业开发时，我们基础每一个业务层方法都需要进行事务的控制，这部分代码属于公共业务且重复的，出现了大量的代码冗余

事务管理器（TransactionManager）

这时候我们可以把这部分代码抽取到工具类（事务管理器）

@Component
public class TransactionManager {
    @Autowired
    private ConnectionUtils connectionUtils;

    //开启事务
    // 1.开启事务
    public void beginTransaction() {
        try {
            connectionUtils.getThreadConnection().setAutoCommit(false);
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }

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

    //回滚事务
    public void rollback() {
        try {
            connectionUtils.getThreadConnection().rollback();
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }

    //释放资源
    public void release() {
        try {
            //回复自动提交事务
            connectionUtils.getThreadConnection().setAutoCommit(true);
            //归还到连接池
            connectionUtils.getThreadConnection().close();
            //将connection对象从当前线程移出
            connectionUtils.removeThreadConnection();
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }
}

@Service
public class AccountServiceImpl implements AccountService {

    //依赖注入accountDao
    @Autowired
    private AccountDao accountDao;

    依赖dataSource
    //@Autowired
    //private DataSource dataSource;

    //@Autowired
    //private ConnectionUtils connectionUtils;

    @Autowired
    private TransactionManager transactionManager;


    @Override
    public void transfer(String outUser, String inUser, Double money) {
        // Connection connection = null;

        //获取conn手动控制事务
        try {
            //connection = dataSource.getConnection();
            //connection = connectionUtils.getThreadConnection();
            //connection.setAutoCommit(false);
            //开启事务
            transactionManager.beginTransaction();
            //业务代码
            //转出

            accountDao.outUser(outUser, money);

            //机器故障

            int i = 1 / 0;

            //转入
            accountDao.inUser(inUser, money);

            //提交事务

            //connection.commit();
            transactionManager.commit();
        } catch (Exception e) {
            e.printStackTrace();
            try {
                //进行事务回滚
                //connection.rollback();
                transactionManager.rollback();
            } finally {
                transactionManager.release();
            }
            // 释放资源
            //try {
            //    // 再改为自动提交
            //    connection.setAutoCommit(true);
            //
            //    connection.close();
            //} catch (SQLException e) {
            //    e.printStackTrace();
            //}
        }

    }
}

@Repository
public class AccountDaoImpl implements AccountDao {

    //依赖queryRunner
    @Autowired
    private QueryRunner queryRunner;
    @Autowired
    private ConnectionUtils connectionUtils;

    @Override
    public void outUser(String outUser, Double money) {
        try {
            String sql = "update account set money=money - ? where name = ?";
            //获取当前线程内的conn
            final Connection threadConnection = connectionUtils.getThreadConnection();
            //执行sql（使用service连接对象）
            queryRunner.update(threadConnection, sql, money, outUser);
        } catch (SQLException e) {
            e.printStackTrace();
        }

    }

    @Override
    public void inUser( String inUser, Double money) {
        try {
            // 1.编写sql
            String sql = "update account set money = money + ?  where name = ?";
            // 获取当前线程内的 conn
            Connection threadConnection = connectionUtils.getThreadConnection();
            // 2.执行sql（使用service连接对象）

            queryRunner.update(threadConnection, sql, money, inUser);
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }
}

问题：几乎所有的方法都需要使用事务管理器，进行事务控制，且事务管理器属于通用业务，与我们核心业务代码产生耦合

转账案例进阶

我们可以将业务代码和事务代码进行拆分，通过动态代理的方式，对业务方法进行事务的增强。这样就不会对业务层产生影响，解决了耦合性的问题啦！
常用的动态代理技术

JDK 代理 : 基于接口的动态代理技术

CGLIB代理：基于父类的动态代理技术

在这里插入图片描述
在企业进行开发时，只有核心业务成代码，不会出现事务相关代码，开发者只需要编写核心业务即可

public void transfer(String outUser, String inUser, Double money) {
    // 业务代码-------- start
    // 转出
    accountDao.outUser(outUser, money);

    // 模拟故障
    int i = 1/0;

    // 转入
    accountDao.inUser(inUser, money);
    // 业务代码-------- end
}

JDK动态代理

目标对象：AccountService
编写JdkProxyFactory

//基于JDK，实现对目标对象的事务增强
@Component
public class JdkProxyFactory {
    @Autowired
    private TransactionManager transactionManager;

    public Object createJdkProxyTx(final Object target) {
        Object proxy = null;
        //使用SUN公司提供的jdk代理工具类
        //目标对象类加载器
        final ClassLoader classLoader = target.getClass().getClassLoader();
        //目标对象接口数组
        final Class<?>[] interfaces = target.getClass().getInterfaces();
        //实现增强的业务逻辑（匿名内部类、Lambda）
        proxy = Proxy.newProxyInstance(classLoader, interfaces, new InvocationHandler() {
            //invoke方法是代理对象的入口
            //proxy：jdk工具类生成的代理对象
            //method：当前用户执行的某个具体方法
            //args：当前用户执行的某个具体方法传递的实际参数列表

            @Override
            public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {

                Object result = null;
                try {
                    //开启事务
                    transactionManager.beginTransaction();
                    //执行目标对象原有的功能
                    result = method.invoke(target, args);
                    //提交事务
                    transactionManager.commit();
                } catch (Exception e) {
                    e.printStackTrace();
                    //回滚事务
                    transactionManager.rollback();
                } finally { //释放资源
                    transactionManager.release();
                }
                return result;
            }

        });
        //返回代理对象（增强后的）
        return proxy;
    }
}


@RunWith(SpringRunner.class)
@ContextConfiguration({"classpath:applicationContext.xml"})
public class AccountTest {

    @Autowired
    private AccountService accountService;//目标对象

    @Autowired
    private JdkProxyFactory jdkProxyFactory;// jdk生产代理对象工厂

    //测试转账案例
    @Test
    public void test01() throws Exception {
        accountService.transfer("tom", "jerry", 100d);
    }

    @Test
    public void test02() throws Exception {
        //accountService.transfer("tom", "jerry", 100d);
        //使用jdk对目标对象进行事务增强
        final AccountService jdkProxyTx = (AccountService) jdkProxyFactory.createJdkProxyTx(accountService);
        jdkProxyTx.transfer("tom", "jerry", 100d);
    }
}

CGLIB动态代理

存在问题：进入公司，可能有些代码没有接口，但又需要动态代理进行增强，这时候sun公司提供jdk工具就无法实现了…
基于CGLIB技术，就可以对普通的java类型实现代理增强，需要导入jar包（Spring框架内置包含了此架包）
目标对象：AccountService
编写CglibProxyFactory

//基于JDK，实现对目标对象的事务增强
@Component
public class JdkProxyFactory {
    @Autowired
    private TransactionManager transactionManager;

    public Object createJdkProxyTx(final Object target) {
        Object proxy = null;
        //使用SUN公司提供的jdk代理工具类
        //目标对象类加载器
        final ClassLoader classLoader = target.getClass().getClassLoader();
        //目标对象接口数组
        final Class<?>[] interfaces = target.getClass().getInterfaces();
        //实现增强的业务逻辑（匿名内部类、Lambda）
        proxy = Proxy.newProxyInstance(classLoader, interfaces, new InvocationHandler() {
            //invoke方法是代理对象的入口
            //proxy：jdk工具类生成的代理对象
            //method：当前用户执行的某个具体方法
            //args：当前用户执行的某个具体方法传递的实际参数列表

            @Override
            public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {

                Object result = null;
                try {
                    //开启事务
                    transactionManager.beginTransaction();
                    //执行目标对象原有的功能
                    result = method.invoke(target, args);
                    //提交事务
                    transactionManager.commit();
                } catch (Exception e) {
                    e.printStackTrace();
                    //回滚事务
                    transactionManager.rollback();
                } finally { //释放资源
                    transactionManager.release();
                }
                return result;
            }

        });
        //返回代理对象（增强后的）
        return proxy;
    }
}

    @Test
    public void test02() throws Exception {
        //accountService.transfer("tom", "jerry", 100d);

        //使用jdk对目标对象进行事务增强
        //final AccountService jdkProxyTx = (AccountService) jdkProxyFactory.createJdkProxyTx(accountService);
        //jdkProxyTx.transfer("tom", "jerry", 100d);

        // 使用cglib对目标对象事务增强
        AccountService cglibProxy = (AccountService) cglibProxyFactory.createCglibProxyTx(accountService);
        cglibProxy.transfer("tom", "jerry", 100d);
    }
}

SpringAOP简介

概述

AOP( 面向切面编程 )是一种思想, 它的目的就是在不修改源代码的基础上,对原有功能进行增强。

Spring AOP是对AOP思想的一种实现, Spring底层同时支持jdk和cglib动态代理。

这样做的好处是：

  1. 在程序运行期间，在不修改源码的情况下对方法进行功能增强
  2. 逻辑清晰，开发核心业务的时候，不必关注增强业务的代码
  3. 减少重复代码，提高开发效率，便于后期维护

Spring会根据被代理的类是否有接口自动选择代理方式:

  • 如果有接口,就采用jdk动态代理( 当然,也可以强制使用cglib )
  • 没有接口就采用cglib的方式

相关术语

  • Target：目标对象
    service层的核心业务（AccountServiceImpl）

  • JoinPoint：连接点
    目标对象中的所有方法
    transfer()
    findAll()

  • Pointcut：切点
    目标对象需要增强的方法
    transfer()

  • Advice：通知（增强）
    实现增强的功能的（TransactionManager）
    beginTransaction()
    commit()
    rollback()
    release()

  • Weaving：织入
    将通知和切点进行织入（动作）

  • Aspect：切面（spring术语）
    通知 + 切点 = 切面

  • Proxy：代理对象（底层实现）
    通知 + 切点 = 代理对象

基于XML的AOP开发

快速入门

创建maven的java模块，导入坐标

在这里插入图片描述

编写目标类

public interface AccountService {
    void transfer();

    void save();
}

编写通知类（增强）

//通知类（增强）
public class MyAdvice {

    //在对目标对象方法执行之前进行增强
    public void before(){
        System.out.println("前置通知");
    }
}

配置Spring的AOP（切点+通知）

在这里插入图片描述

测试

@RunWith(SpringRunner.class)
@ContextConfiguration("classpath:applicationContext.xml")
public class AccountTest {
    @Autowired
    private AccountService accountService; // 配置了aop之后，就成为了代理对象

    @Test
    public void test01() throws Exception {
        accountService.save();//保存了

        accountService.transfer();//前置通知,转账了
    }
}
PETRICHOR03
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Spring框架是在2003年兴起的一门轻量级的JAVAEE框架技术 Spring框架学习资料第三天
10-29
Spring框架学习资料第三天 Spring框架是2003年兴起的一门轻量级的JAVAEE框架技术。 Spring框架学习资料第三天主要涵盖了AOP、Spring动态代理的实现原理、SM整合（Spring+Mybatis）等知识点。 一、AOP（面向切面...
手写spring简单实现转账--体会核心ioc和aop
baidu_38652335的博客
05-23 346
文章目录 前言 spring是全栈的轻量级的开源框架，本文就通过一个简单的案例帮助大家理解其ioc和aop大致是如何实现的。 一、转账案例 首先我们设定一个需求：简单转账功能比如A向B转账 步骤: 首先需要先查询一下 A的余额 判断是否能够转钱，如果能够转钱执行下面 如果不能就返回转账失败 余额不足。 当余额足够时 查询B的余额将需要转账的钱加上之前的余额 再通过修改语句改变B的余额。 A的余额为 A原来的余额减去需要转账的钱 然后再调用修改语句改变A的余额。 出现异常事务...
spring基础知识
佛系小菜鸡的博客
12-18 389
我们一般的开发基本上有两种模式：C/S架构（客户端与服务器端）、B/S架构（浏览器端和服务器端），而java非常适合做B/S架构 spring是什么 spring是全栈式轻量级框架，以IOC和AOP为核心，提供了表现层SpringMVC和和持久层 Spring JDBC以及业务层事物管理等众多的企业级应用技术，还能整合众多第三方框架和类库，逐渐成为使用最多的java EE企业应用开源框架。 S...
Spring-学习笔记07【银行转账案例】
upward
02-13 781
Spring-学习笔记07【银行转账案例】
转账案例(使用ThreadLocal对象把Connection和当前线程绑定)
少营营的博客
07-04 978
转账案例 【需求】：姓名为aaa的账号取出100元给姓名为bbb的账号 准备工作： 第一步：创建工程spring_day03_account 第二步：导入坐标，pom.xml <?xml version="1.0" encoding="UTF-8"?> <project xmlns="http://maven.apache.org/POM/4.0.0" ...
ConnectionUtils
ads1213141的博客
07-08 629
/** * @date 2019/7/8 9:35 * 管理连接的工具类 用于实现连接和线程的绑定 * 保证当前线程获得的 Connection 是同一个 */@Componentpublic class ConnectionUtils { private ThreadLocal<Connection> tl=new ThreadLocal<Conne...
Spring框架是在2003年兴起的一门轻量级的JAVAEE框架技术 Spring框架学习资料第二天
10-29
Spring 框架学习资料第二天 本篇文章主要讲解了 Spring 框架的第二天学习资料，涵盖了 FactoryBean、Spring 工厂配置文件的参数化、静态代理、AOP 开发等知识点。 一、FactoryBean FactoryBean 是 Spring 框架中...
Spring框架是在2003年兴起的一门轻量级的JAVAEE框架技术 Spring框架学习资料第四天
10-29
"Spring框架学习资料第四天：事务控制" Spring框架是2003年兴起的一门轻量级的JAVAEE框架技术。本文主要介绍Spring框架中的事务控制机制，涵盖了事务的基本概念、JDBC和Mybatis中的事务控制、Spring中的事务控制...
Spring框架是在2003年兴起的一门轻量级的JAVAEE框架技术 Spring框架学习资料第一天
10-29
Spring框架学习资料第一天 一、Spring框架简介 * Spring框架是在2003年兴起的一门轻量级的JAVAEE框架技术 * Spring框架的诞生目的是致力于全面的简化JAVAEE企业级应用的开发 * Spring框架采用了很多的设计模式：...
Spring框架是在2003年兴起的一门轻量级的JAVAEE框架技术 Spring框架学习资料第五天
最新发布
10-29
Spring框架，作为2003年崛起的一款轻量级...通过以上学习，你可以深入理解Spring框架的核心特性，掌握如何利用注解进行事务管理和开发，以及如何进行SSM集成和单元测试。不断实践将有助于提升你的Spring开发技能。
基于xml的AOP实现事务控制
一蓑烟雨任平生
05-27 156
package com.itheima.dao.impl; import com.itheima.dao.IAccountDao; import com.itheima.domain.Account; import com.itheima.utils.ConnectionUtils; import org.apache.commons.dbutils.QueryRunner; import org.apache.commons.dbutils.handlers.BeanHandler; import o.
Spring—学习笔记#day03
安藤青司的博客
08-05 731
目录 1、完善我们的account案例 2、分析案例中问题 新的问题 3、动态代理回顾 动态代理的特点 动态代理常用的有两种方式 4、基于接口的动态代理 5、基于子类的动态代理 使用 CGLib的Enhancer类创建代理对象 环境配置 6、解决案例中的问题 7、AOP的相关概念[理解] 7.1AOP概述 7.1.1什么是 AOP 7.1.2AOP的作用及优势 ...
SpringAOP需要解决的问题
RestartJava的博客
05-28 359
SpringAOP需要解决的问题1. 传统编码的事务问题业务流程新的问题，当我们把事务交给service后，出现的问题。 1. 传统编码的事务问题 sql的事务，存在于Connection（连接中），默认情况下都是自动提交，我们每一次执行一条sql语句都会获取一个Connection连接，而在正常情况下，我们的业务可能会操作多条sql语句，这些sql语句要么同时生效，要么同时回滚。 也就是说事务的控制不能在dao层中，必须要在service中进行。 如何保证多条sql同时生效，或同时回滚？ 保证执行多条sq
使用aop解决事务问题（xml版）
L-李俊漩的博客
05-28 322
一、引入依赖 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:schema...
将connection存放在Threadlocal里和数据库连接池的区别
maikelsong的专栏
11-10 5528
我有几点不太明白的，望各位大侠指教下。 1、j2ee的应用中，有一个用户请求就会启动一个线程。而如果我们把connection放在Threadlocal里的话，那么我们的程序只需要一个connection连接数据库就行了，每个线程都是用的connection的一个副本，那为什么还有必要要数据库连接池呢？ 2、在这种情况下一个副本里的connection执行了关闭操作，其他都没执行。那么想问一下
Spring DataSourceUtils.getConnection与DataSource.getConnection
HD243608836的博客
12-21 7773
DataSource.getConnection()总是从datasource或连接池返回一个新的连接。 通过调用 jdbcTemplate.getDataSource().getConnection()显式获取一个连接，这个连接不是方法事务上下文线程绑定的连接，所以如果开发者如果没有手工释放这连接（显式调用 Connection#close() 方法），则这个连接将永久被占用（处于 active...
03 Spring 简单事务 动态代理 AOP
壹仟的博客
04-28 470
事务分析 ThreadLocal 作用 可以让多个操作都是用同一个连接 ThreadLocal对象把Connection和当前线程绑定, 从而使线程中只有一个能控制事务的对象 ...
21.【利用工具类解决事务不同步问题】
Luis
04-05 194
获取连接的工具类 连接的工具类，它用于从数据源中获取一个连接，并且实现和线程的绑定和解绑：ThreadLocal 有多个连接时无法控制事务 代码： package cn.luis.utils; import javax.sql.DataSource; import java.sql.Connection; /** * */ public class ConnectionUtils {...
spring中一个方法出现多个连接问题解决（动态代理解决事务问题方式来引出AOP）
ljwjojoyy的博客
05-22 406
dbutils的QueryRunner对象每次都要创建新的，在执行操作时都要从数据源中拿出一个连接，导致很多连接(多例)，没出异常的连接提交了，出现异常后数据没有从一个一致的状态跳到另一个一致的状态。一个方法中的所有操作都应该用同一个连接。 编写一个工具类，使得一个线程中只有一个能控制事务的对象 package com.wei.utils; import javax.sql.DataSource; import java.sql.Connection; /** * 连接的工具类，它用于从...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值