三、Spring JDBCTemplate & 声明式事务

最新推荐文章于 2024-09-25 11:56:42 发布
最新推荐文章于 2024-09-25 11:56:42 发布
阅读量225 收藏
点赞数
分类专栏： SSM 文章标签： spring mysql sql
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_48893653/article/details/120801268
版权

一、Spring JDBCTemplate

1.JDBCTemplate是什么？

JdbcTemplate是spring框架中提供的一个模板对象，对原始繁琐的Jdbc API对象的简单封装。
核心对象

JdbcTemplate jdbcTemplate = new JdbcTemplate(DataSource dataSource);

核心方法

int update(); 执行增、删、改语句
List<T> query(); 查询多个
T queryForObject(); 查询一个
	new BeanPropertyRowMapper<>(); 实现ORM映射封装

举个栗子

public class JdbcTemplateTest {
	@Test
	public void testFindAll() throws Exception {
	// 创建核心对象
	JdbcTemplate jdbcTemplate = new JdbcTemplate(JdbcUtils.getDataSource());
	// 编写sql
	String sql = "select * from account";
	// 执行sql
	List<Account> list = jdbcTemplate.query(sql, new BeanPropertyRowMapper<Account>
	(Account.class));
	}
}

account表

CREATE TABLE `account` (
  `id` int(11) NOT NULL AUTO_INCREMENT,
  `name` varchar(32) DEFAULT NULL,
  `money` double DEFAULT NULL,
  PRIMARY KEY (`id`)
) ENGINE=InnoDB AUTO_INCREMENT=6 DEFAULT CHARSET=utf8

jdbc.properties

jdbc.driverClassName=com.mysql.jdbc.Driver
jdbc.url=jdbc:mysql:///spring_db
jdbc.username=root
jdbc.password=root

2.Spring整合JDBCTemplate

需求： 基于Spring的xml配置实现账户的CRUD操作

①：导入依赖坐标

	<dependencies>
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>5.1.47</version>
        </dependency>
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>druid</artifactId>
            <version>1.1.15</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>5.1.5.RELEASE</version>
        </dependency>
        <dependency>
            <groupId>org.aspectj</groupId>
            <artifactId>aspectjweaver</artifactId>
            <version>1.8.13</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-jdbc</artifactId>
            <version>5.1.5.RELEASE</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-tx</artifactId>
            <version>5.1.5.RELEASE</version>
        </dependency>
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.12</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-test</artifactId>
            <version>5.1.5.RELEASE</version>
        </dependency>
    </dependencies>

②：编写Account实体类

/**
 * @author 徐国文
 * @create 2021-10-16 12:18
 * Account实体类对应者数据库中得account表
 */
public class Account {

    private Integer id;
    private String name;
    private Double money;
}

③：编写AccountDao接口和实现类

/**
 * @author 徐国文
 * @create 2021-10-16 12:19
 */
public interface AccountDao {
    /**
     * 查询所有账户
     * @return
     */
    List<Account> findAll();

    /**
     * 根据id查询账户信息
     * @param id
     * @return
     */
    Account findById(Integer id);

    /**
     * 保存账户
     * @param account
     */
    void save(Account account);

    /**
     * 更新账户信息
     * @param account
     */
    void update(Account account);

    /**
     * 根据id删除账户信息
     * @param id
     */
    void delete(Integer id);
}

/**
 * @author 徐国文
 * @create 2021-10-16 12:21
 */
@Repository
public class AccountDaoImpl implements AccountDao {

    @Autowired
    private JdbcTemplate jdbcTemplatel;

    public List<Account> findAll() {
        String sql = "select * from account";
        List<Account> list = jdbcTemplatel.query(sql, new BeanPropertyRowMapper<Account>(Account.class));
        return list;
    }

    public Account findById(Integer id) {
        String sql = "select * from account where id = ?";
        Account account = jdbcTemplatel.queryForObject(sql, new BeanPropertyRowMapper<Account>(Account.class), id);
        return account;
    }

    public void save(Account account) {
        String sql = "insert into account values(null,?,?)";
        jdbcTemplatel.update(sql,account.getName(),account.getMoney());
    }

    public void update(Account account) {
        String sql = "update account set money = ? where name = ?";
        jdbcTemplatel.update(sql,account.getMoney(),account.getName());
    }

    public void delete(Integer id) {
        String sql = "delete from account where id = ?";
        jdbcTemplatel.update(sql,id);
    }
}

④：编写AccountService接口和实现类

/**
 * @author 徐国文
 * @create 2021-10-16 12:26
 */
public interface AccountService {
    /**
     * 查询所有账户
     * @return
     */
    List<Account> findAll();

    /**
     * 根据id查询账户信息
     * @param id
     * @return
     */
    Account findById(Integer id);

    /**
     * 保存账户
     * @param account
     */
    void save(Account account);

    /**
     * 更新账户信息
     * @param account
     */
    void update(Account account);

    /**
     * 根据id删除账户信息
     * @param id
     */
    void delete(Integer id);
}

/**
 * @author 徐国文
 * @create 2021-10-16 12:27
 */
@Service
public class AccountServiceImpl implements AccountService {
    @Autowired
    private AccountDao accountDao;

    public List<Account> findAll() {
        return accountDao.findAll();
    }

    public Account findById(Integer id) {
        return accountDao.findById(id);
    }

    public void save(Account account) {
        accountDao.save(account);
    }

    public void update(Account account) {
        accountDao.update(account);
    }

    public void delete(Integer id) {
        accountDao.delete(id);
    }
}

⑤：编写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"
       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">
    <!--IOC注解扫描-->
    <context:component-scan base-package="cn.xguowen"/>

    <context:property-placeholder location="classpath:jdbc.properties"/>

    <bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource">
        <property name="driverClassName" value="${jdbc.driverClassName}"/>
        <property name="url" value="${jdbc.url}"/>
        <property name="username" value="${jdbc.username}"/>
        <property name="password" value="${jdbc.password}"/>
    </bean>
    <bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">
        <constructor-arg name="dataSource" ref="dataSource"/>
    </bean>
</beans>

⑥：测试

/**
 * @author 徐国文
 * @create 2021-10-16 12:34
 */
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration({"classpath:applicationContext.xml"})
public class TestSpringJdbcTemplate {
    @Autowired
    private AccountService accountService;

    // 测试保存
    @Test
    public void testSave() {
        Account account = new Account();
        account.setName("马双");
        account.setMoney(1000d);
        accountService.save(account);
    }

    // 测试查询所有
    @Test
    public void testFindAll() {
        List<Account> list = accountService.findAll();
        for (Account account : list) {
            System.out.println(account);
        }
    }

    // 测试根据id查询账户
    @Test
    public void testFindById() {
        Account account = accountService.findById(1);
        System.out.println(account);
    }

    // 测试修改账户信息
    @Test
    public void testUpdate() {
        Account account = new Account();
        account.setMoney(1000d);
        account.setName("徐国文");
        accountService.update(account);
    }
    // 测试根据id删除账户信息
    @Test
    public void testDelete() {
        accountService.delete(5);
    }
}

3.Spring整合JDBCTemplate 实现转账案例

①：导入依赖坐标

<dependencies>
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>5.1.47</version>
        </dependency>
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>druid</artifactId>
            <version>1.1.15</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>5.1.5.RELEASE</version>
        </dependency>
        <dependency>
            <groupId>org.aspectj</groupId>
            <artifactId>aspectjweaver</artifactId>
            <version>1.8.13</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-jdbc</artifactId>
            <version>5.1.5.RELEASE</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-tx</artifactId>
            <version>5.1.5.RELEASE</version>
        </dependency>
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.12</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-test</artifactId>
            <version>5.1.5.RELEASE</version>
        </dependency>
    </dependencies>

②：编写Account实体类

③：编写AccountDao接口和实现类

/**
 * @author 徐国文
 * @create 2021-10-16 14:59
 */
public interface AccountDao {
    /**
     * 转出操作
     * @param outUser 转出账户
     * @param money   转出金额
     */
    void out(String outUser,Double money);

    /**
     * 转入操作
     * @param inUser 转入账户
     * @param money  转入金额
     */
    void in(String inUser,Double money);
}

/**
 * @author 徐国文
 * @create 2021-10-16 15:02
 */
@Repository
public class AccountDaoImpl implements AccountDao {

    @Autowired
    private JdbcTemplate jdbcTemplate;
    /**
     * 转出操作
     * @param outUser 转出账户
     * @param money   转出金额
     */
    public void out(String outUser, Double money) {
        String sql = "update account set money = money - ? where name = ?";
        jdbcTemplate.update(sql,money,outUser);
    }

    /**
     * 转入操作
     * @param inUser 转入账户
     * @param money  转入金额
     */
    public void in(String inUser, Double money) {
        String sql = "update account set money = money + ? where name = ?";
        jdbcTemplate.update(sql,money,inUser);
    }
}

④：编写AccountService接口和实现类

/**
 * @author 徐国文
 * @create 2021-10-16 15:04
 */
public interface AccountService {
    /**
     * 转入转出操作
     * @param outUser 转出账户
     * @param inUser  转入账户
     * @param money   金额
     */
    void transfer(String outUser,String inUser,Double money);
}


/**
 * @author 徐国文
 * @create 2021-10-16 15:05
 */
@Service
public class AccountServiceImpl implements AccountService {
    @Autowired
    private AccountDao accountDao;

    public void transfer(String outUser, String inUser, Double money) {

        // 转出操作
        accountDao.out(outUser,money);

        // int i = 1 / 0;

        // 转入操作
        accountDao.in(inUser,money);
    }
}

⑤：编写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"
       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">

    <!--开启IOC注解扫描-->
    <context:component-scan base-package="cn.xuguowen"/>

    <!--加载外部的properties文件-->
    <context:property-placeholder location="classpath:jdbc.properties"/>

    <bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource">
        <property name="driverClassName" value="${jdbc.driverClassName}"/>
        <property name="url" value="${jdbc.url}"/>
        <property name="username" value="${jdbc.username}"/>
        <property name="password" value="${jdbc.password}"/>
    </bean>

    <bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">
        <constructor-arg name="dataSource" ref="dataSource"/>
    </bean>
</beans>

⑥：测试

/**
 * @author 徐国文
 * @create 2021-10-16 15:11
 */
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration({"classpath:applicationContext.xml"})
public class SpringJdbcTemplateTx {
    @Autowired
    private AccountService accountService;

    @Test
    public void testTransfer() {
        accountService.transfer("tom","jerry",100d);
    }
}

二、Spring的事务

1.Spring中的事务控制方式

Spring的事务控制可以分为编程式事务控制和声明式事务控制。
编程式： 开发者直接把事务的代码和业务代码耦合到一起，在实际开发中不用。
声明式： 开发者采用配置的方式来实现的事务控制，业务代码与事务代码实现解耦合，使用的AOP思想。

2.编程式事务控制相关对象【了解】

①：PlatformTransactionManager

PlatformTransactionManager接口，是spring的事务管理器，里面提供了我们常用的操作事务的方法。

方法说明
TransactionStatus getTransaction(TransactionDefinition definition)获取事务的状态信息
void commit(TransactionStatus status)提交事务
void rollback(TransactionStatus status)回滚事务

注意

* PlatformTransactionManager 是接口类型，不同的 Dao 层技术则有不同的实现类。
   * Dao层技术是jdbcTemplate或mybatis时：
   		DataSourceTransactionManager
   * Dao层技术是hibernate时：
   		HibernateTransactionManager
   * Dao层技术是JPA时：
   		JpaTransactionManager

②： TransactionDefinition

TransactionDefinition接口提供事务的定义信息（事务隔离级别、事务传播行为等等）

方法说明
int getIsolationLevel()获得事务的隔离级别
int getPropogationBehavior()获得事务的传播行为
int getTimeout()获得超时时间
boolean isReadOnly()是否只读
a)： 事务隔离级别

设置隔离级别，可以解决事务并发产生的问题，如脏读、不可重复读、幻读（虚读）。

* ISOLATION_DEFAULT 使用数据库默认级别
* ISOLATION_READ_UNCOMMITTED 读未提交
* ISOLATION_READ_COMMITTED 读已提交
* ISOLATION_REPEATABLE_READ 可重复读
* ISOLATION_SERIALIZABLE 串行化
b)： 事务传播行为

事务传播行为指的就是当一个业务方法【被】另一个业务方法调用时，应该如何进行事务控制。

参数说明
REQUIRED如果当前没有事务，就新建一个事务，如果已经存在一个事务中，加入到这个事务中。一般的选择（默认值）
SUPPORTS支持当前事务，如果当前没有事务，就以非事务方式执行（没有事务）
MANDATORY使用当前的事务，如果当前没有事务，就抛出异常
REQUERS_NEW新建事务，如果当前在事务中，把当前事务挂起
NOT_SUPPORTED以非事务方式执行操作，如果当前存在事务，就把当前事务挂起
NEVER以非事务方式运行，如果当前存在事务，抛出异常
NESTED如果当前存在事务，则在嵌套事务内执行。如果当前没有事务，则执行 REQUIRED 类似的操作

在这里插入图片描述

c)： read-only（是否只读）：建议查询时设置为只读
d)： timeout（超时时间）：默认值是-1，没有超时限制。如果有，以秒为单位进行设置

③： TransactionStatus

TransactionStatus 接口提供的是事务具体的运行状态。

方法说明
boolean isNewTransaction()是否是新事务
boolean hasSavepoint()是否是回滚点
boolean isRollbackOnly()事务是否回滚
boolean isCompleted()事务是否完成

可以简单的理解三者的关系：事务管理器通过读取事务定义参数进行事务管理，然后会产生一系列的事务状态。

④：代码实现

a)：配置文件
<!--事务管理器交给IOC-->
<bean id="transactionManager"class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
  <property name="dataSource" ref="dataSource"/>
</bean>
b)：业务层代码
@Service
public class AccountServiceImpl implements AccountService {
  @Autowired
  private AccountDao accountDao;
  @Autowired
  private PlatformTransactionManager transactionManager;
  @Override
  public void transfer(String outUser, String inUser, Double money) {
  	// 创建事务定义对象
  	DefaultTransactionDefinition def = new DefaultTransactionDefinition();
  	// 设置是否只读，false支持事务
  	def.setReadOnly(false);
  	// 设置事务隔离级别，可重复读mysql默认级别
  	def.setIsolationLevel(TransactionDefinition.ISOLATION_REPEATABLE_READ);
  	// 设置事务传播行为，必须有事务
  	def.setPropagationBehavior(TransactionDefinition.PROPAGATION_REQUIRED);
  	// 配置事务管理器
  	TransactionStatus status = transactionManager.getTransaction(def);
  	try {
  	// 转账
  	accountDao.out(outUser, money);
  	accountDao.in(inUser, money);
  	// 提交事务
  	transactionManager.commit(status);
  	} catch (Exception e) {
  	e.printStackTrace();
  	// 回滚事务
  	transactionManager.rollback(status);
  	}
  }
}

3.基于XML的声明式事务【重点】

在 Spring 配置文件中声明式的处理事务来代替代码式的处理事务。底层采用AOP思想来实现的。
声明式事务控制明确事项：

	- 核心业务代码（目标对象）（切入点是谁？）
	- 事务增强代码（Spring已提供事务管理器）（通知）
	- 切面配置（切面如何配置）

①：快速入门

需求： 使用spring声明式事务控制转账业务。

a)：引入tx命名空间
<?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:tx="http://www.springframework.org/schema/tx"
       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/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">
 </beans>
b)： 事务管理器通知配置
  <bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource">
        <property name="driverClassName" value="${jdbc.driverClassName}"/>
        <property name="url" value="${jdbc.url}"/>
        <property name="username" value="${jdbc.username}"/>
        <property name="password" value="${jdbc.password}"/>
 </bean>
<!--事务管理器-->
<bean id="transactionManager"class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
	<property name="dataSource" ref="dataSource"></property>
</bean>
<!--通知增强-->
<tx:advice id="txAdvice" transaction-manager="transactionManager">
	<!--定义事务的属性-->
	<tx:attributes>
		<!--  1.name="*" 表示当前任意名称的方法都走默认配置（事务隔离级别，传播信息……）-->
		<tx:method name="*"/>
	</tx:attributes>
</tx:advice>
c)： 事务管理器AOP切面配置
	<aop:config>
        <aop:advisor advice-ref="txAdvice" pointcut="execution(* cn.xuguowen.service.impl.AccountServiceImpl.transfer(..))"/>
    </aop:config>
d)：测试事务控制转账业务代码
public void transfer(String outUser, String inUser, Double money{
        // 转出操作
        accountDao.out(outUser,money);

        int i = 1 / 0;

        // 转入操作
        accountDao.in(inUser,money);
}

②：事务参数的配置详解

<tx:method name="transfer" isolation="REPEATABLE_READ" propagation="REQUIRED"
timeout="-1" read-only="false"/>
* name：切点方法名称
* isolation:事务的隔离级别
* propogation：事务的传播行为
* timeout：超时时间
* read-only：是否只读

CRUD常用配置
	根据事务的传播行为进行事务管理器属性的配置，CRUD常用配置
                   这样一来：就需要我们的方法名称规范了起来，
                    如果是增删改 saveXxx() updateXxx() deleteXxx(),
                    如果是查询 findXxx()
                    如果不是增删改查的方法，就一切都走默认配置
<tx:attributes>
	<tx:method name="save*" propagation="REQUIRED"/>
	<tx:method name="delete*" propagation="REQUIRED"/>
	<tx:method name="update*" propagation="REQUIRED"/>
	<tx:method name="find*" read-only="true"/>
	<tx:method name="*"/>
</tx:attributes>

4.基于注解的声明式事务【重点】

①：修改service层，增加事务注解


/**
 * @author 徐国文
 * @create 2021-10-16 15:05
 */
@Service
@Transactional
public class AccountServiceImpl implements AccountService {
    @Autowired
    private AccountDao accountDao;
    // 使用Spring声明式事务增强
    // 当然也可以使该类中的所有方法都接收事务的控制，那么就在该类上添加这个注解，事务的配置都使用默认配置
    // @Transactional(propagation = Propagation.REQUIRED,isolation = Isolation.REPEATABLE_READ,readOnly = false,timeout = -1)
    public void transfer(String outUser, String inUser, Double money) {
        // 转出操作
        accountDao.out(outUser,money);

        int i = 1 / 0;

        // 转入操作
        accountDao.in(inUser,money);
    }
}

②：在核心配置文件中，开启事务注解支持

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w2.org/2001/XMLSchema-instance"
xmlns:context="http://www.springframework.org/schema/context"
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/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
http://www.springframework.org/schema/tx
http://www.springframework.org/schema/tx/spring-tx.xsd">
	<!--省略之前datsSource、jdbcTemplate、组件扫描配置-->
	<!--事务管理器-->
	<bean id="transactionManager"
class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
		<property name="dataSource" ref="dataSource"></property>
	</bean>
	<!--事务的注解支持-->
	<tx:annotation-driven/>
</beans>

5.纯注解

①：核心配置类

/**
 * @author 徐国文
 * @create 2021-10-17 11:57
 */
@Configuration // 表示该类是spring的核心配置类
@ComponentScan("cn.xuguowen")   // IOC注解扫描
@Import(DataSourceConfig.class) // 引入数据源配置类
@EnableTransactionManagement    // 开启声明式事务注解扫描
public class SpringConfig {

    @Bean
    public JdbcTemplate getJdbcTemplate(@Autowired DataSource dataSource) {
        JdbcTemplate jdbcTemplate = new JdbcTemplate(dataSource);
        return jdbcTemplate;
    }

    @Bean
    public PlatformTransactionManager getPlatformTransactionManager(@Autowired DataSource dataSource) {
        DataSourceTransactionManager dataSourceTransactionManager = new DataSourceTransactionManager(dataSource);
        return dataSourceTransactionManager;
    }
}

②：数据源配置类

/**
 * @author 徐国文
 * @create 2021-10-17 11:58
 * 数据源配置类
 */
@PropertySource("classpath:jdbc.properties")    // 加载jdbc.properties配置
public class DataSourceConfig {
    @Value("${jdbc.driverClassName}")
    private String driver;
    @Value("${jdbc.url}")
    private String url;
    @Value("${jdbc.username}")
    private String username;
    @Value("${jdbc.password}")
    private String password;

    @Bean   // 将方法的返回值交给IOC容器管理
    public DataSource getDataSource() {
        DruidDataSource druidDataSource = new DruidDataSource();
        druidDataSource.setDriverClassName(driver);
        druidDataSource.setUrl(url);
        druidDataSource.setUsername(username);
        druidDataSource.setPassword(password);
        return druidDataSource;
    }
}

jdbc.driverClassName=com.mysql.jdbc.Driver
jdbc.url=jdbc:mysql:///spring_db
jdbc.username=root
jdbc.password=root

三、Spring集成Web环境

1. ApplicationContext应用上下文获取方式

应用上下文对象是通过 new ClasspathXmlApplicationContext(spring配置文件) 方式获取的，但是每次从容器中获得Bean时都要编写new ClasspathXmlApplicationContext(spring配置文件) 。这样的弊端就是配置文件被加载多次，应用上下文对象创建多次。
解决思路分析：
在Web项目中，可以使用ServletContextListener监听Web应用的启动，我们可以在Web应用启动时，就加载Spring的配置文件，创建应用上下文对象ApplicationContext，在将其存储到ServletContext的域中，这样就可以在任意位置从域中获得应用上下文ApplicationContext对象了。

2. Spring提供获取应用上下文的工具

上面的分析不用手动实现，Spring提供了一个监听器ContextLoaderListener就是对上述功能的封装，该监听器内部加载Spring配置文件，创建应用上下文对象，并存储到ServletContext域中，提供了一个客户端工具 WebApplicationContextUtils供使用者获得应用上下文对象。

所以我们需要做的只有两件事：

	- 1.在web.xml中配置ContextLoaderListener监听器（导入spring-web坐标）
	- 2.使用WebApplicationContextUtils获得应用上下文对象ApplicationContext

3. 实现

①：导入Spring集成web坐标

	<dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-web</artifactId>
            <version>5.1.5.RELEASE</version>
    </dependency>

②：在web.xml文件中配置ContextLoaderListener监听器

    <!--我们得告诉spring得监听器，配置文件得位置在哪-->
    <context-param>
        <!--key必须使用这个key-->
        <param-name>contextConfigLocation</param-name>
        <param-value>classpath:applicationContext.xml</param-value>
    </context-param>
    <!--
        Spring监听器，监听web应用启动
            1.加载spring得核心配置文件
            2.创建spring的上下文对象
            3.将创建的上下文对象存储到servletContext域中
    -->
    <listener>
        <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
    </listener>

③：通过客户端工具类获得应用上下文对象

 		// 使用提供得客户端工具类获取spring得上下文对象
        ApplicationContext applicationContext = WebApplicationContextUtils.getWebApplicationContext(this.getServletContext());
        Account account = (Account) applicationContext.getBean("account");
        System.out.println(account);
MyikJ
关注
专栏目录
Spring JdbcTemplate&声明式事务1
08-04
总结起来，Spring JdbcTemplate简化了数据库操作，而声明式事务管理则使事务处理更加便捷。通过这两个工具，开发者可以更专注于业务逻辑，而不是底层的数据库操作和事务管理细节。结合使用，它们为基于Spring的应用...
Spring框架(四)——JdbcTemplate和声明式事务管理
weixin_44240370的博客
04-21 980
文章目录一、JdbcTemplate1、概述2、环境准备3、持久化操作前期准备<1>update<2>batchUpdate<3>queryForObject<4>query4、使用具名参数的JdbcTemplate<1>、通过IOC容器创建<2>、具名参数传入二、声明式事务管理1、事务概述3、Bookshop案例<1&...
JdbcTemplate和声明式事务（Spring框架）
热门推荐
wangligong的博客
11-18 1万+
Spring框架整理第三发，JdbcTemplate的使用和声明式事务。 JdbcTemplate       简介：JdbcTemplate是Spring框架提供的操作数据库的工具类，功能和DBUtils类似  JdbcTemplate使用方法：       导包： 数据库连接： c3p0-0.9.1.2.jar  mysql-connector-jav
Spring JdbcTemplate&声明式事务.md
08-06
Spring JdbcTemplate&声明式事务.md
day4-Spring JdbcTemplate & 声明式事务.md
10-15
### Spring JdbcTemplate与声明式事务知识点详解 #### JdbcTemplate基本使用概述 JdbcTemplate是Spring框架提供的用于简化JDBC API操作的对象。它通过提供一个高级抽象层来减少编码工作量，并帮助开发者避免处理...
Spring注解 TX声明式事务实现过程解析
08-19
Spring 注解 TX 声明式事务实现过程解析 本文将详细介绍 Spring 注解 TX 声明式事务实现过程，通过示例代码和详细的分析，向读者展示如何使用 Spring 注解实现声明式事务。首先，让我们从环境搭建开始。 环境搭建 ...
spring 声明式事务实现过程解析
08-25
Spring 声明式事务实现过程解析 Spring 声明式事务实现过程解析是指使用Spring框架提供的声明式事务管理机制来管理事务的实现过程。声明式事务管理是指不需要手动编写事务相关代码，而是通过配置和注解来管理事务的...
SpringBoot Validation不生效该怎么办？
最新发布
m0_63164811的博客
09-25 135
SpringBoot Validation不生效该怎么办？
springboot注册和注入组件方式概览
CamphorBlossom的博客
09-21 298
依赖：组件的依赖关系，如 NewsController 依赖 NewsServices。注入：通过setter方法、构造器、等方式自动的注入（赋值）控制：资源的控制权（资源的创建、获取、销毁等）xxxAware（标记接口，让调用者获取到Spring容器中的其他资源引用）反转：和传统的方式不一样了。理解单例，获取组件的方式（通过bean的类型，名称获取）理解setter方法注入，构造器注入。Conditional 派生注解。理解MVC分层模型对应注解。
SpringCloud config native 配置
rita_0567的博客
09-19 760
- Eureka-Server 依赖 -->org.springframework.cloudspring-cloud-starter-netflix-eureka-server
Spring 事务与 MySQL 事务：深度解析与实战指南
果酱 の 博客
09-19 1128
事务是一个逻辑工作单元，它包含了一组数据库操作，这些操作要么全部成功执行，要么全部回滚，以保证数据的一致性和完整性。例如，在银行转账系统中，从一个账户转出资金并转入另一个账户的操作就应该在一个事务中进行，以确保资金的正确转移，不会出现部分操作成功而部分操作失败的情况。Spring 事务与 MySQL 事务的结合为企业级应用开发提供了强大的事务管理功能。
springboot acuturator
pscool的博客
09-21 244
基础使用步骤 - 系统学习。
SpringBoot+Thymeleaf图书管理系统
qq_61863348的博客
09-20 413
这是一个基于SpringBoot+Thymeleaf实现的图书管理系统。> 包含图书管理、作者管理、分类管理、出版社管理等功能。> 界面简洁美观，代码结构清晰，完成度比较高，适用于JAVA初学者作为参考项目。
Springboot 文件上传下载相关问题
quokka56的博客
09-21 525
Springboot 文件上传下载问题 保姆级教程
Spring IoC 配置类 总结
持续学习和分享感兴趣的技术
09-19 289
Spring中可以使用配置类完全代替xml来配置IoC容器。
SpringCloud从零开始简单搭建 - JDK17
qq_43657722的博客
09-20 857
博客讲述 SpringCloud + Nacos 从零搭建，基于 JDK17。内容包括创建父项目、子项目，集成 Nacos 及其配置中心，是简易搭建的步骤指南。
Spring6梳理10—— 依赖注入之注入数组类型属性
haozihua的博客
09-22 281
以上笔记来源：尚硅谷Spring零基础入门到进阶，一套搞定spring6全套视频教程（源码级讲解）
SpringBoot自定义网站导航
qq_61863348的博客
09-25 386
这是一个基于 **Spring Boot** 构建的简单网站导航，适用于JAVA初学者。> 使用了 **Spring Boot**、**Spring Security**、**Thymeleaf**、**Spring Data JPA**、**Spring Data REST** 框架。> 数据库使用了基于内存的 **H2数据库**，无需单独安装，随Spring Boot启动。- 包含用户登录和注册功能。- 用户可以添加网页链接并为其打标签。链接也会根据给定链接的网站数据抓取进行推荐。
2.Seata 1.5.2 集成Springcloud-alibaba
huangchong0107的博客
09-21 984
详见。
Spring JdbcTemplate入门与声明式事务详解
在Spring框架中，第四个主题"day4-Spring JdbcTemplate & 声明式事务"主要关注了Java中的JdbcTemplate和声明式事务处理。JdbcTemplate是Spring提供的一种简化JDBC编程的工具，它封装了底层的JDBC API，使得开发者...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值