spring04

最新推荐文章于 2023-07-31 15:09:00 发布
最新推荐文章于 2023-07-31 15:09:00 发布
阅读量138 收藏
点赞数
分类专栏： spring
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_45636163/article/details/107661610
版权

JDBCTemplate
它是 spring 框架中提供的一个对象，是对原始 Jdbc API 对象的简单封装。spring 框架为我们提供了很多的操作模板类。
操作关系型数据的：JdbcTemplate、HibernateTemplate
操作 nosql 数据库的：RedisTemplate
操作消息队列的：JmsTemplate

案例
import org.springframework.jdbc.core.support.JdbcDaoSupport;可以统一配置持久层实现类中的getJdbcTemplate，配置文件中就无需配置，直接配置DataSource

<!-- 配置账户的持久层-->
    <bean id="accountDao" class="com.itheima.dao.impl.AccountDaoImpl">
        <!--<property name="jdbcTemplate" ref="jdbcTemplate"></property>-->
        <property name="dataSource" ref="dataSource"></property>
    </bean>

bean.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"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
        http://www.springframework.org/schema/beans/spring-beans.xsd">

    <!-- 配置账户的持久层-->
    <bean id="accountDao" class="com.itheima.dao.impl.AccountDaoImpl">
        <!--<property name="jdbcTemplate" ref="jdbcTemplate"></property>-->
        <property name="dataSource" ref="dataSource"></property>
    </bean>

    <!--配置JdbcTemplate
    <bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">
        <property name="dataSource" ref="dataSource"></property>
    </bean>-->

    <!-- 配置数据源-->
    <bean id="dataSource" class="org.springframework.jdbc.datasource.DriverManagerDataSource">
        <property name="driverClassName" value="com.mysql.jdbc.Driver"></property>
        <property name="url" value="jdbc:mysql://localhost:3306/eesy"></property>
        <property name="username" value="root"></property>
        <property name="password" value="1234"></property>
    </bean>
</beans>

AccountDaoImpl xml配置

package com.itheima.dao.impl;

import com.itheima.dao.IAccountDao;
import com.itheima.domain.Account;
import org.springframework.jdbc.core.BeanPropertyRowMapper;
import org.springframework.jdbc.core.support.JdbcDaoSupport;

import java.util.List;

/**
 * 账户的持久层实现类
 */
public class AccountDaoImpl extends JdbcDaoSupport implements IAccountDao {

    @Override
    public Account findAccountById(Integer accountId) {
        List<Account> accounts = super.getJdbcTemplate().query("select * from account where id = ?",new BeanPropertyRowMapper<Account>(Account.class),accountId);
        return accounts.isEmpty()?null:accounts.get(0);
    }

    @Override
    public Account findAccountByName(String accountName) {
        List<Account> accounts = super.getJdbcTemplate().query("select * from account where name = ?",new BeanPropertyRowMapper<Account>(Account.class),accountName);
        if(accounts.isEmpty()){
            return null;
        }
        if(accounts.size()>1){
            throw new RuntimeException("结果集不唯一");
        }
        return accounts.get(0);
    }

    @Override
    public void updateAccount(Account account) {
        super.getJdbcTemplate().update("update account set name=?,money=? where id=?",account.getName(),account.getMoney(),account.getId());
    }
}

AccountDaoImpl2 注解配置时采用

package com.itheima.dao.impl;

import com.itheima.dao.IAccountDao;
import com.itheima.domain.Account;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.jdbc.core.BeanPropertyRowMapper;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.stereotype.Repository;

import java.util.List;

/**
 * 账户的持久层实现类
 */
@Repository
public class AccountDaoImpl2 implements IAccountDao {

    @Autowired
    private JdbcTemplate jdbcTemplate;


    @Override
    public Account findAccountById(Integer accountId) {
        List<Account> accounts = jdbcTemplate.query("select * from account where id = ?",new BeanPropertyRowMapper<Account>(Account.class),accountId);
        return accounts.isEmpty()?null:accounts.get(0);
    }

    @Override
    public Account findAccountByName(String accountName) {
        List<Account> accounts = jdbcTemplate.query("select * from account where name = ?",new BeanPropertyRowMapper<Account>(Account.class),accountName);
        if(accounts.isEmpty()){
            return null;
        }
        if(accounts.size()>1){
            throw new RuntimeException("结果集不唯一");
        }
        return accounts.get(0);
    }

    @Override
    public void updateAccount(Account account) {
        jdbcTemplate.update("update account set name=?,money=? where id=?",account.getName(),account.getMoney(),account.getId());
    }
}

JdbcDaoSupport

package com.itheima.dao.impl;

/**
 * 此类用于抽取dao中的重复代码

public class JdbcDaoSupport {

    private JdbcTemplate jdbcTemplate;

    public void setJdbcTemplate(JdbcTemplate jdbcTemplate) {
        this.jdbcTemplate = jdbcTemplate;
    }

    public JdbcTemplate getJdbcTemplate() {
        return jdbcTemplate;
    }


    public void setDataSource(DataSource dataSource) {
        if(jdbcTemplate == null){
            jdbcTemplate = createJdbcTemplate(dataSource);
        }
    }

    private JdbcTemplate createJdbcTemplate(DataSource dataSource){
        return new JdbcTemplate(dataSource);
    }
}
 */

JdbcTemplateDemo4

package com.itheima.jdbctemplate;

import com.itheima.dao.IAccountDao;
import com.itheima.domain.Account;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

/**
 * JdbcTemplate的最基本用法
 */
public class JdbcTemplateDemo4 {

    public static void main(String[] args) {
        //1.获取容器
        ApplicationContext ac = new ClassPathXmlApplicationContext("bean.xml");
        //2.获取对象
        IAccountDao accountDao = ac.getBean("accountDao",IAccountDao.class);

        Account account = accountDao.findAccountById(1);
        System.out.println(account);

        account.setMoney(30000f);
        accountDao.updateAccount(account);
    }
}

基于注解的AOP事务控制 在实现事务通知时，只能使用环绕通知

Spring 中的事务控制
JavaEE 体系进行分层开发，事务处理位于业务层，Spring 提供了分层设计业务层的事务处理解决方案。
spring 的事务控制都是基于 AOP 的，它既可以使用编程的方式实现，也可以使用配置的方式实现。学习的重点是使用配置的方式实现。

Spring 中事务控制的 API 介绍 PlatformTransactionManager 提供事务操作方法，具体有获取事务状态信息，提交 回滚事务
具体实现类：真正管理事务的对象org.springframework.jdbc.datasource.DataSourceTransactionManager 使用 Spring JDBC 或 iBatis 进行持久化数据时使用org.springframework.orm.hibernate5.HibernateTransactionManager 使用Hibernate 版本进行持久化数据时使用

TransactionDefinition：事务的定义信息对象
事务的隔离级别
事务的传播行为
REQUIRED:如果当前没有事务，就新建一个事务，如果已经存在一个事务中，加入到这个事务中。一般的选择（默认值） 增删改
SUPPORTS:支持当前事务，如果当前没有事务，就以非事务方式执行（没有事务） 查
TransactionStatus 提供的是事务具体的运行状态 是否存在存储点 事务按照步骤提交，每个存储点都是事务的一步，执行成功提交这一步，出现错误回滚只回滚到这一步。

spring基于xml和注解的事务控制

spring中基于XML的声明式事务控制配置步骤
1、配置事务管理器
2、配置事务的通知
此时我们需要导入事务的约束 tx名称空间和约束，同时也需要aop的
使用tx:advice标签配置事务通知
属性：
id：给事务通知起一个唯一标识
transaction-manager：给事务通知提供一个事务管理器引用
3、配置AOP中的通用切入点表达式
4、建立事务通知和切入点表达式的对应关系
5、配置事务的属性
是在事务的通知tx:advice标签的内部

<?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:aop="http://www.springframework.org/schema/aop"
       xmlns:tx="http://www.springframework.org/schema/tx"
       xsi:schemaLocation="
        http://www.springframework.org/schema/beans
        http://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/tx
        http://www.springframework.org/schema/tx/spring-tx.xsd
        http://www.springframework.org/schema/aop
        http://www.springframework.org/schema/aop/spring-aop.xsd">

    <!-- 配置业务层-->
    <bean id="accountService" class="com.itheima.service.impl.AccountServiceImpl">
        <property name="accountDao" ref="accountDao"></property>
    </bean>

    <!-- 配置账户的持久层-->
    <bean id="accountDao" class="com.itheima.dao.impl.AccountDaoImpl">
        <property name="dataSource" ref="dataSource"></property>
    </bean>


    <!-- 配置数据源-->
    <bean id="dataSource" class="org.springframework.jdbc.datasource.DriverManagerDataSource">
        <property name="driverClassName" value="com.mysql.jdbc.Driver"></property>
        <property name="url" value="jdbc:mysql://localhost:3306/eesy"></property>
        <property name="username" value="root"></property>
        <property name="password" value="1234"></property>
    </bean>

    <!-- spring中基于XML的声明式事务控制配置步骤
        1、配置事务管理器
        2、配置事务的通知
                此时我们需要导入事务的约束 tx名称空间和约束，同时也需要aop的
                使用tx:advice标签配置事务通知
                    属性：
                        id：给事务通知起一个唯一标识
                        transaction-manager：给事务通知提供一个事务管理器引用
        3、配置AOP中的通用切入点表达式
        4、建立事务通知和切入点表达式的对应关系
        5、配置事务的属性
               是在事务的通知tx:advice标签的内部

     -->
    <!-- 配置事务管理器 -->
    <bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
        <property name="dataSource" ref="dataSource"></property>
    </bean>

    <!-- 配置事务的通知-->
    <tx:advice id="txAdvice" transaction-manager="transactionManager">
        <!-- 配置事务的属性
                isolation：用于指定事务的隔离级别。默认值是DEFAULT，表示使用数据库的默认隔离级别。
                propagation：用于指定事务的传播行为。默认值是REQUIRED，表示一定会有事务，增删改的选择。查询方法可以选择SUPPORTS。
                read-only：用于指定事务是否只读。只有查询方法才能设置为true。默认值是false，表示读写。
                timeout：用于指定事务的超时时间，默认值是-1，表示永不超时。如果指定了数值，以秒为单位。
                rollback-for：用于指定一个异常，当产生该异常时，事务回滚，产生其他异常时，事务不回滚。没有默认值。表示任何异常都回滚。
                no-rollback-for：用于指定一个异常，当产生该异常时，事务不回滚，产生其他异常时事务回滚。没有默认值。表示任何异常都回滚。
        -->
        <tx:attributes>
            <tx:method name="*" propagation="REQUIRED" read-only="false"/>
            <tx:method name="find*" propagation="SUPPORTS" read-only="true"></tx:method>
        </tx:attributes>
    </tx:advice>

    <!-- 配置aop-->
    <aop:config>
        <!-- 配置切入点表达式-->
        <aop:pointcut id="pt1" expression="execution(* com.itheima.service.impl.*.*(..))"></aop:pointcut>
        <!--建立切入点表达式和事务通知的对应关系 -->
        <aop:advisor advice-ref="txAdvice" pointcut-ref="pt1"></aop:advisor>
    </aop:config>

</beans>

注解配置

<?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:aop="http://www.springframework.org/schema/aop"
       xmlns:tx="http://www.springframework.org/schema/tx"
       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/tx
        http://www.springframework.org/schema/tx/spring-tx.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.itheima"></context:component-scan>

    <!-- 配置JdbcTemplate-->
    <bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">
        <property name="dataSource" ref="dataSource"></property>
    </bean>

    <!-- 配置数据源-->
    <bean id="dataSource" class="org.springframework.jdbc.datasource.DriverManagerDataSource">
        <property name="driverClassName" value="com.mysql.jdbc.Driver"></property>
        <property name="url" value="jdbc:mysql://localhost:3306/eesy"></property>
        <property name="username" value="root"></property>
        <property name="password" value="1234"></property>
    </bean>

    <!-- spring中基于注解 的声明式事务控制配置步骤
        1、配置事务管理器
        2、开启spring对注解事务的支持
        3、在需要事务支持的地方使用@Transactional注解

     -->
    <!-- 配置事务管理器 -->
    <bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
        <property name="dataSource" ref="dataSource"></property>
    </bean>


    <!-- 开启spring对注解事务的支持-->
    <tx:annotation-driven transaction-manager="transactionManager"></tx:annotation-driven>

</beans>

package com.itheima.service.impl;

import com.itheima.dao.IAccountDao;
import com.itheima.domain.Account;
import com.itheima.service.IAccountService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Propagation;
import org.springframework.transaction.annotation.Transactional;

/**
 * 账户的业务层实现类
 *
 * 事务控制应该都是在业务层
 */
@Service("accountService")
@Transactional(propagation= Propagation.SUPPORTS,readOnly=true)//只读型事务的配置
public class AccountServiceImpl implements IAccountService{

    @Autowired
    private IAccountDao accountDao;


    @Override
    public Account findAccountById(Integer accountId) {
        return accountDao.findAccountById(accountId);

    }


    //需要的是读写型事务配置
    @Transactional(propagation= Propagation.REQUIRED,readOnly=false)
    @Override
    public void transfer(String sourceName, String targetName, Float money) {
        System.out.println("transfer....");
            //2.1根据名称查询转出账户
            Account source = accountDao.findAccountByName(sourceName);
            //2.2根据名称查询转入账户
            Account target = accountDao.findAccountByName(targetName);
            //2.3转出账户减钱
            source.setMoney(source.getMoney()-money);
            //2.4转入账户加钱
            target.setMoney(target.getMoney()+money);
            //2.5更新转出账户
            accountDao.updateAccount(source);

            int i=1/0;

            //2.6更新转入账户
            accountDao.updateAccount(target);
    }
}

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"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
        http://www.springframework.org/schema/beans/spring-beans.xsd">

    <!-- 配置业务层-->
    <bean id="accountService" class="com.itheima.service.impl.AccountServiceImpl">
        <property name="accountDao" ref="accountDao"></property>
        <property name="transactionTemplate" ref="transactionTemplate"></property>
    </bean>

    <!-- 配置账户的持久层-->
    <bean id="accountDao" class="com.itheima.dao.impl.AccountDaoImpl">
        <property name="dataSource" ref="dataSource"></property>
    </bean>


    <!-- 配置数据源-->
    <bean id="dataSource" class="org.springframework.jdbc.datasource.DriverManagerDataSource">
        <property name="driverClassName" value="com.mysql.jdbc.Driver"></property>
        <property name="url" value="jdbc:mysql://localhost:3306/eesy"></property>
        <property name="username" value="root"></property>
        <property name="password" value="1234"></property>
    </bean>

    <!-- 配置事务管理器-->
    <bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
        <property name="dataSource" ref="dataSource"></property>
    </bean>

    <!--配置事务模板对象-->
    <bean id="transactionTemplate" class="org.springframework.transaction.support.TransactionTemplate">
        <property name="transactionManager" ref="transactionManager"></property>
    </bean>
</beans>

Spring5 的新特性
从索引读取实体而不是扫描类路径对于小于 200 个类的小型项目是没有明显差异。但对大型项目影响较大。加载组件索引开销更低。因此，随着类数的增加，索引读取的启动时间将保持不变。

JetBrains Kotlin 语言支持
响应式编程风格
Junit5 支持

weixin_45636163
关注
专栏目录
Spring04
2401_87079968的博客
10-18 778
使用SpringJdbc技术实现项目与数据库的连接 1.准备spring-jdbc依赖的坐标(mysql、spring-jdbc) 2.通过创建Jdbc模板类的对象实现对数据库的操作
我设计的简单事务控制
weixin_34320159的博客
11-02 100
其中数据库操作使用了Microsoft.ApplicationBlocks，请参考我的《Microsoft.ApplicationBlocks使用心得》类结构图：相关文件：接口：IManager.cs IPlanManager.cs实现：Manager.cs PlanManager.cs使用：Test.cs其他相关文件不予说明Test.cs:测试客户端，可以进行单个功能类内多个方法的事务控制，如果...
Spring 基于AOP的事务控制
Smily-王婷婷
07-05 2702
文章目录WhatHow基于XML声明式事务的配置基于注解的声明式事务 What  事务是我们在进行数据操作的时候，要操作的事情，是一个完整的单元，不可再分的。它包括几个特性：原子性、一致性、可见性、隔离性； How  在Spring容器中，事务是被封装到事务管理器中，Spring事务管理器的接口是org.springframework.transaction.PlatformTransaction...
Spring中AOP相关的API及源码解析，原来AOP是这样子的
热门推荐
做一个认真的程序员
07-02 1万+
Spring中AOP相关的API及源码解析 本系列文章： 读源码，我们可以从第一行读起 你知道Spring是怎么解析配置类的吗？ 配置类为什么要添加@Configuration注解？ 谈谈Spring中的对象跟Bean，你知道Spring怎么创建对象的吗？ 这篇文章，我们来谈一谈Spring中的属性注入 推荐阅读： Spring官网阅读 | 总结篇 Spring杂谈 本系列文章将会带你一行行的将Spring的源码吃透，推荐阅读的文章是阅读源码的基础！ 因为本文会涉及到动态代理的相关内容，如果对动态代理不
API接口记录AOP
凌峰的博客
10-24 188
注解 import java.lang.annotation.ElementType; import java.lang.annotation.Retention; import java.lang.annotation.RetentionPolicy; import java.lang.annotation.Target; /** * 使用该注解后,会将API接口操作记录存储到DB中 * ...
spring的aop与事务处理API，代替之前自己写的事务处理
qq_42762824的博客
12-16 263
清楚其中事务处理的原理，而后懂API，才能不至于根基不牢，问啥啥不会 使用Spring 事务管理API的步骤 1、配置事务管理器 2、配置事务的通知 此时我们需要导入事务的约束 tx名称空间和约束，同时也需要aop的 使用tx:advice标签配置事务通知 属性： id：给事务通知起一个唯一标识 transaction-manager：给事务通知提供一个事务管理器引用 3、配置AOP中的通用切入点表达式 4、建立事务通知和切入点表达式的对应关系 5、配置事务的属性 是在事务的通知tx:advice标签的内部
spring04-5
07-12
《Spring AOP实践详解——基于"spring04-5"项目》 在Spring框架中，AOP（面向切面编程）是一种强大的设计模式，它允许我们以声明式的方式处理横切关注点，如日志、事务管理、权限控制等。本篇文章将深入探讨通过...
spring04-4
07-12
标题“spring04-4”指的是一个关于Spring框架AOP（面向切面编程）实践的教程或项目。在这个练习中，开发者将学习如何在Spring框架中应用AOP来实现特定的功能，而描述“spring的aop的练习，代码可供参考，仅是aop功能...
spring04-3
07-12
在本项目"spring04-3"中，我们主要探讨的是Spring框架中的核心特性之一——面向切面编程（Aspect-Oriented Programming, AOP）。AOP是Spring提供的一种强大机制，它允许我们在不修改源代码的情况下，对应用程序的...
spring04-2
07-12
标题"spring04-2"暗示了这是一个关于Spring AOP的实践项目，而描述则提到这是一次针对AOP功能的练习，提供了可供参考的代码，但尚未进行优化。 AOP在Spring框架中的作用是允许开发者声明式地管理横切关注点，如日志...
Spring API级别对AOP的支持
交换一个思想，能得到俩思想
04-30 2621
在Spring 2.0之前,Spring通过定义一套接口和通过ProxyFactoryBean来生产bean实例提供对AOP的支持,在2.0后,Spring推荐通过AspectJ兼容的方式来实现AOP.见http://blog.csdn.net/kkdelta/archive/2010/04/22/5515882.aspx 1,定义'方面'拦截器,最常用的接口有: MethodIntercep
使用Spring的API接口实现AOP
你今天真好看呀
10-23 606
使用AOP，需要导入一个jar包： <!-- https://mvnrepository.com/artifact/org.aspectj/aspectjweaver --> <dependency> <groupId>org.aspectj</groupId> <artifactId>aspectjweaver</art...
Spring 中的事务控制
Lemon
09-19 472
一、事务控制 JavaEE 体系进行分层开发，事务处理位于业务层，Spring 提供了分层设计业务层的事务处理解决方案 Spring 框架为我们提供了一组事务控制的接口。这组接口是在spring-tx-5.0.2.RELEASE.jar 中 Spring 的事务控制都是基于 AOP 的，它既可以使用编程的方式实现，也可以使用配置的方式实现 二、事务控制的 API 1、PlatformTrans...
Spring框架关于事务处理的API和使用步骤
sunms
06-24 262
Spring中的事务管理全部要经过事务管理器来实现. 因此无论是注解的方式还是xml的方式实现的事务都必须要配置事务管理器. 因为事务是基于数据库连接的,所以事务管理器依赖于连接池创建的连接,因此事务管理器需要注入连接池属性. 一.Spring基于注解的事务管理 spring 关于事务管理的3个API: PlatformTransactionManager ①DataSourceTransactionManager:JDBC的事务管理器 ②HibernateTransactionManager:Hi.
Spring 事务API
weixin_42325327的博客
11-06 184
一.事务的概念和特性： 事务指的是逻辑上的一组操作，这组操作要么全部成功，要么全部失败。 特性： 1.原子性 事务是数据库的逻辑工作单位，事务中包含的各操作要么都做，要么都不做。 2.一致性 一致性指事务前后的完整性必须保持一致 3.隔离性 一个事务执行不能被其他事务干扰。即一个事务内部的操作及使用的数据对其它并发事务是隔离的，并发执行的各...
事务策略api层策略_API层策略
cusi77914的博客
07-02 757
无论您是使用带有EJB 2.1或3.0的容器环境，Spring Framework环境，还是带有Java Open Transaction Manager（JOTM）的Web容器环境（例如Tomcat或Jetty），您仍然需要一种事务策略来确保数据库的一致性和完整性。 。 Java Transaction API（JTA）指定了与事务处理关联的语法和接口（请参阅参考资料 ），但是没有描述如何将...
Spring~事务API、事务失效原因、事务传播特性
Shangxingya的博客
02-27 421
文章目录Spring事务事务API实现原理事务失效事务传播机制 Spring事务 Spring事务是在所使用的数据库事务的基础上进行封装扩展 封装主要是封装了一些JDBC的一写事务操作的对象, 扩展主要有以下几点特性 加入了事务传播的概念, 从代码逻辑上看来比编程式事务简化很多 提供声明式事务或者是注解式配置事务，让业务代码与事务分离，事务变得更易用(AOP技术) 但是也造成了事务失效的情况出现, 具体原因下面讲述 事务API Spring提供了一个TransactionDefinition, 它定义了
万字干货！Spring基于AOP事务控制实现原理全解
最新发布
wdj_yyds的博客
07-31 303
对于一个系统应用而言，使用数据库进行数据存储是必然的，意味着开发过程中事务的使用及控制也是必不可少的，当然事务是数据库层面的知识点并不是Spring框架所提出的。使用JDBC开发时，我们使用对事务进行控制，使用MyBatis时，我们使用SqlSession对事务进行控制，缺点显而易见，当我们切换数据库访问技术时，事务控制的方式总会变化，所以Spring就在这些技术基础上，提供了统一的控制事务的接口。Spring的事务分为：编程式事务控制和声明式事务控制。编程式事务控制。
自动注入的closeablehttpclient对象总是空指针_狂神说Spring04：自动装配
06-13
这可能是因为您没有在Spring的配置文件中正确地配置CloseableHttpClient Bean，或者您的自动注入方式不正确。请确保您已经在配置文件中正确地声明了CloseableHttpClient Bean，并且使用了正确的注解（如@Autowired或@Resource）将其注入到需要使用它的类中。您还可以检查一下CloseableHttpClient Bean的作用域，确保它与您需要使用它的类的作用域相匹配。如果以上方法都无法解决问题，您可以尝试在代码中手动创建CloseableHttpClient对象并使用它。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值