spring基于注解和xml声明式事务控制

最新推荐文章于 2024-10-14 14:50:26 发布
最新推荐文章于 2024-10-14 14:50:26 发布
阅读量118 收藏
点赞数
文章标签： mysql spring
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_44648148/article/details/106044642
版权

1.xml

dao

package com.wzk.dao;

import com.wzk.domain.Account;

public interface AccountDao  {

    Account findById(Integer accountId);

    Account findByName(String name);

    void updateAccount(Account account);
}




package com.wzk.dao.impl;

import com.wzk.dao.AccountDao;
import com.wzk.domain.Account;
import org.springframework.jdbc.core.BeanPropertyRowMapper;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.jdbc.core.support.JdbcDaoSupport;

import java.util.List;

public class AccountDaoImpl extends JdbcDaoSupport implements AccountDao {



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

    @Override
    public Account findByName(String name) {
        List<Account> accounts = getJdbcTemplate().query("select * from account where name = ?",new BeanPropertyRowMapper<Account>(Account.class),name);
        if(accounts.isEmpty()){
            return null;
        }else{
            return accounts.get(0);
        }
    }

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

service

package com.wzk.service;

import com.wzk.domain.Account;

public interface AccountService {

    Account findAccountById(Integer accountId);

    void transfer(String sourceName,String targerName,Float money);
}




package com.wzk.service.impl;

import com.wzk.dao.AccountDao;
import com.wzk.dao.impl.AccountDaoImpl;
import com.wzk.domain.Account;
import com.wzk.service.AccountService;

public class AccountServiceImpl implements AccountService {

    private AccountDaoImpl accountDaoImpl;

    public void setAccountDao(AccountDaoImpl accountDaoImpl) {
        this.accountDaoImpl = accountDaoImpl;
    }

    @Override
    public Account findAccountById(Integer accountId) {
        return accountDaoImpl.findById(accountId);
    }

    @Override
    public void transfer(String sourceName, String targetName, Float money) {
        Account source = accountDaoImpl.findByName(sourceName);
        Account target = accountDaoImpl.findByName(targetName);
        source.setMoney(source.getMoney() - money);
        target.setMoney(target.getMoney() + money);
        accountDaoImpl.updateAccount(source);
        int i = 1/0;
        accountDaoImpl.updateAccount(target);
    }
}

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: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.wzk.service.impl.AccountServiceImpl">
        <property name="accountDao" ref="accountDao"></property>
    </bean>

    <bean id="accountDao" class="com.wzk.dao.impl.AccountDaoImpl">
<!--        <property name="template" ref="jdbcTemplate"></property>-->
        <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/spring"></property>
        <property name="username" value="root"></property>
        <property name="password" value="root"></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="tl" expression="execution(* com.wzk.service.impl.*.*(..))"/>
        <!-- 建立切入点表达式和事务通知的对应关系 -->
        <aop:advisor advice-ref="txAdvice" pointcut-ref="tl"></aop:advisor>
    </aop:config>
</beans>

测试类

package com.wzk.test;

import com.wzk.service.AccountService;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(locations = "classpath:bean.xml")
public class JdbcTest {

    @Autowired
    private AccountService as;

    @Test
    public void test(){
        as.transfer("aaa","bbb",100f);
    }
}

半注解半xml

package com.wzk.dao;

import com.wzk.domain.Account;

public interface AccountDao  {

    Account findById(Integer accountId);

    Account findByName(String name);

    void updateAccount(Account account);
}


package com.wzk.dao.impl;

import com.wzk.dao.AccountDao;
import com.wzk.domain.Account;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.jdbc.core.BeanPropertyRowMapper;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.jdbc.core.support.JdbcDaoSupport;
import org.springframework.stereotype.Repository;

import java.util.List;

@Repository("accountDao")
public class AccountDaoImpl implements AccountDao {

    @Autowired
    private JdbcTemplate template;

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

    @Override
    public Account findByName(String name) {
        List<Account> accounts = template.query("select * from account where name = ?",new BeanPropertyRowMapper<Account>(Account.class),name);
        if(accounts.isEmpty()){
            return null;
        }else{
            return accounts.get(0);
        }
    }

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


package com.wzk.service;

import com.wzk.domain.Account;

public interface AccountService {

    Account findAccountById(Integer accountId);

    void transfer(String sourceName, String targerName, Float money);
}


package com.wzk.service.impl;

import com.wzk.dao.AccountDao;
import com.wzk.dao.impl.AccountDaoImpl;
import com.wzk.domain.Account;
import com.wzk.service.AccountService;
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 AccountService {

    @Autowired
    private AccountDaoImpl accountDaoImpl;

    @Override
    public Account findAccountById(Integer accountId) {
        return accountDaoImpl.findById(accountId);
    }

    //需要读写型事务
    @Transactional(propagation = Propagation.REQUIRED,readOnly = false)
    @Override
    public void transfer(String sourceName, String targetName, Float money) {
        System.out.println("transfer");
        Account source = accountDaoImpl.findByName(sourceName);
        Account target = accountDaoImpl.findByName(targetName);
        source.setMoney(source.getMoney() - money);
        target.setMoney(target.getMoney() + money);
        accountDaoImpl.updateAccount(source);
        int i = 1/0;
        accountDaoImpl.updateAccount(target);
    }
}


<?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">

    <context:component-scan base-package="com.wzk"></context:component-scan>
    <bean id="template" 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/spring"></property>
        <property name="username" value="root"></property>
        <property name="password" value="root"></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.wzk.test;

import com.wzk.service.AccountService;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(locations = "classpath:bean.xml")
public class JdbcTest {

    @Autowired
    private AccountService as;

    @Test
    public void test(){
        as.transfer("aaa","bbb",100f);
    }
}

全注解

dao和service

package com.wzk.dao;

import com.wzk.domain.Account;

public interface AccountDao  {

    Account findById(Integer accountId);

    Account findByName(String name);

    void updateAccount(Account account);
}




package com.wzk.dao.impl;

import com.wzk.dao.AccountDao;
import com.wzk.domain.Account;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.jdbc.core.BeanPropertyRowMapper;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.jdbc.core.support.JdbcDaoSupport;
import org.springframework.stereotype.Repository;

import java.util.List;

@Repository("accountDao")
public class AccountDaoImpl implements AccountDao {

    @Autowired
    private JdbcTemplate template;

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

    @Override
    public Account findByName(String name) {
        List<Account> accounts = template.query("select * from account where name = ?",new BeanPropertyRowMapper<Account>(Account.class),name);
        if(accounts.isEmpty()){
            return null;
        }else{
            return accounts.get(0);
        }
    }

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





package com.wzk.service;

import com.wzk.domain.Account;

public interface AccountService {

    Account findAccountById(Integer accountId);

    void transfer(String sourceName, String targerName, Float money);
}




package com.wzk.service.impl;

import com.wzk.dao.AccountDao;
import com.wzk.dao.impl.AccountDaoImpl;
import com.wzk.domain.Account;
import com.wzk.service.AccountService;
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 AccountService {

    @Autowired
    private AccountDaoImpl accountDaoImpl;

    @Override
    public Account findAccountById(Integer accountId) {
        return accountDaoImpl.findById(accountId);
    }

    //需要读写型事务
    @Transactional(propagation = Propagation.REQUIRED,readOnly = false)
    @Override
    public void transfer(String sourceName, String targetName, Float money) {
        System.out.println("transfer");
        Account source = accountDaoImpl.findByName(sourceName);
        Account target = accountDaoImpl.findByName(targetName);
        source.setMoney(source.getMoney() - money);
        target.setMoney(target.getMoney() + money);
        accountDaoImpl.updateAccount(source);
        //int i = 1/0;
        accountDaoImpl.updateAccount(target);
    }
}

config的配置

package config;

import org.springframework.context.annotation.*;
import org.springframework.transaction.annotation.EnableTransactionManagement;

/**
 * spring的配置类，相当于bean.xml
 */
@Configuration
@ComponentScan("com.wzk")
@Import({JdbcConfig.class,TransactionConfig.class})
@PropertySource("jdbcConfig.properties")
@EnableTransactionManagement
public class SpringConfiguration {
}


package config;

import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Bean;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.jdbc.datasource.DriverManagerDataSource;

import javax.sql.DataSource;

/**
 * 和数据库相关的配置类
 */
public class JdbcConfig {

    @Value("${driver}")
    private String driver;

    @Value("${url}")
    private String url;

    @Value("${user}")
    private String username;

    @Value("${password}")
    private String password;

    /**
     * 创建JdbcTemplate对象
     * @param dataSource
     * @return
     */
    @Bean(name="jdbcTemplate")
    public JdbcTemplate createJdbcTemplate(DataSource dataSource){
        return new JdbcTemplate(dataSource);
    }

    /**
     * 创建数据源对象
     * @return
     */
    @Bean(name="dataSource")
    public DataSource createDataSource(){
        DriverManagerDataSource ds = new DriverManagerDataSource();
        ds.setDriverClassName(driver);
        ds.setUrl(url);
        ds.setUsername(username);
        ds.setPassword(password);
        return ds;
    }
}


package config;

import org.springframework.context.annotation.Bean;
import org.springframework.jdbc.datasource.DataSourceTransactionManager;
import org.springframework.transaction.PlatformTransactionManager;

import javax.sql.DataSource;

/**
 * 和事务相关的配置
 */
public class TransactionConfig {

    /**
     * 用于创建事务管理器对象
     * @param dataSource
     * @return
     */
    @Bean(name="transactionManager")
    public PlatformTransactionManager createTransactionManager(DataSource dataSource){
        return new DataSourceTransactionManager(dataSource);
    }
}

jdbc.properties文件

driver=com.mysql.jdbc.Driver
url=jdbc:mysql://localhost:3306/spring
user=root
password=root
骑着王八环游世界
关注
Spring基于xml和注解事务控制
wangke的博客
03-17 113
1.明确： Spring提供了一组处理事务的接口，这组接口在Spring-tx中。 2.xml配置： <?xml version="1.0" encoding="UTF-8"?> <beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/X...
[JAVAEE]实验06：基于XML和基于注解的声明式事务管理方式模拟银行转账程序
Topus的博客
04-15 1493
一、实验目的： 熟练掌握声明式事务管理。 二、实验内容： 编写一个模拟银行转账的程序，要求在转账时通过Spring对事务进行控制。 三、实验要求： 分别使用基于XML和基于注解的声明式事务管理方式来实现。 四、设计 1.数据表设计：id money name 2.Dao数据库层： 根据用户的id查询用户的余额信息 根据用户的id查询的姓名 根据id存钱 根据id取钱 3.service层： 根据用...
声明式事务（XML和注解）
lc1062657810的博客
06-10 250
XML配置声明式事务：（基本不用） 声明式事务(xml)：为的是无论spring集成什么dao框架，我们不用写事务代码 1.开始将事务管理者配置到核心容器 2.注入数据源 3.配置事务 3.1 tx配置事务规则 事务规则： name就是方法名 事务规则作用的范围 rol
spring 基于注解 和 基于xml管理事务
东方
07-16 129
基于xml <bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource" > <property name="driverClass" value="com.mysql.jdbc.Driver"></property> <property name...
Spring中基于xml和注解的声明式事务控制配置步骤
零栀
02-03 260
Spring中基于xml的声明式事务控制配置步骤     1.配置事务管理器 <!-- 配置事务管理器 --> <bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager"> <...
Spring如何管理事务(声明式事务的两种方式XML和注解)
Wsl_Cn的博客
07-23 255
Spring管理事务对象 PlatformTransactionManager 平台事务管理器 commit rollback TransactionDefinition 事务定义 描述了事务基本信息 TansactionSatus（状态设计模式） 描述事务状态 声明式事务 去除了通知类的编写 使用xml中的tx:advice标签，替换原本自己写的通知类 单独控制某些方法的事务属性 tx:attributes 编写aop相关配置完成通知和具体方法的关系 流程 1.
Spring 整合mybatis(注解&xml版声明式事务).pdf
04-09
在声明式事务管理中，我们可以在业务逻辑方法上添加注解或配置XML来控制事务，而不需要在代码中显式地使用事务API来管理事务。这种方式可以让开发者专注于业务逻辑的实现，而由框架来保证事务的ACID属性。 在整合的...
Spring实战之使用注解实现声明式事务操作示例
08-25
在本文中，我们将详细介绍如何使用 Spring 框架来实现声明式事务操作，通过对配置文件和接口实现的分析，来描述如何使用注解来实现事务操作。 事务管理 在 Spring 框架中，事务管理是通过实现 ...
SpringBoot 注解事务声明式事务的方式
08-29
本文将深入探讨Spring Boot中如何使用注解进行声明式事务的管理。 首先，Spring Boot默认集成了Spring Data JPA、MyBatis等持久层框架，它们都支持注解事务。注解事务的核心是`@Transactional`，这是Spring提供的一...
Spring使用AspectJ注解和XML配置实现AOP
09-01
在Spring框架中，面向切面编程（AOP）是一种强大的设计模式，它允许开发者定义“切面”，这些切面封装了关注点，如日志、事务管理或安全控制，然后将这些切面逻辑透明地应用到业务代码上。本主题将深入探讨如何使用...
基于XML和注解的声明式事物控制
qq_41095435的博客
01-18 164
步骤 基于xml 配置pom.xml文件 构建业务代码 配置ApplicationContext.xml文件 测试 1 pom.xml文件中需要添加的依赖 <!--spring-context.jar 这个jar 文件为Spring 核心提供了大量扩展。可以找到使用Spring ApplicationContext特性时所需的全部类，JDNI 所需的全部类，instrumentation组件以及校验Validation 方面的相关类。 外部依赖spring-beans, (spring-ao
Spring声明式事务管理（xml和纯注解方式）
differ_li的博客
03-23 338
案例环境准备： 数据库表、实体类； dao层： /** * 账户的持久层实现类 * 此版本dao，只需要给它的父类注入一个数据源 */ public class AccountDaoImpl extends JdbcDaoSupport implements AccountDao { @Override public Account findAccountById(Inte...
spring的编程式事务和声明式事务管理（xml方式和注解方式）
mengyue113的博客
05-20 506
1.事务     1.1.事务的四大特性ACID        （1）原子性（Atomicity）事务所包含的操作，要么全部成功，要么全部失败回滚，具有不可分割性。        （2）一致性（Consistency）事务执行前和执行之后都必须处于一致性状态。        （3）隔离性（Isolation）多个并发事务之间要相互隔离。        （4）持久性（Durability）事务一旦提...
spring事物配置，声明式事务管理和基于@Transactional注解的使用
热门推荐
不学习就淘汰
12-04 30万+
事务管理对于企业应用来说是至关重要的，即使出现异常情况，它也可以保证数据的一致性。 spring支持编程式事务管理和声明式事务管理两种方式。 编程式事务管理使用TransactionTemplate或者直接使用底层的PlatformTransactionManager。对于编程式事务管理，spring推荐使用TransactionTemplate。  声明式事务管理建立在
基于XML和注解的声明式事务控制
博主很懒，没有简介~
03-16 482
本文以账户转账的demo演示spring分别基于xml和注解的声明式事务控制。讲述声明式事务控制配置步骤。
基于xml的声明式事务控制和基于注解的声明式事务控制
YKbsmn的博客
12-04 345
1 基于xml的声明式事务控制 1.1什么是声明式事务控制 Spring的声明式事务顾名思义就是采用声明的方式来处理事务。这里所说的声明，就是指在配置文件中声明，用在Spring配置文件中声明式的处理事务来代替代码式的处理事务。 1.2声明式事务处理的作用 （1）事务管理不侵入开发的组件。具体来说，业务逻辑对象就不会意识到正在事务管理之中，事实上也应该如此，因为事务管理是属于系统层面的服务，而不是业务逻辑的一部分，如果想要改变事务管理策划的话，也只需要在定义文件中重新配置即可。（相当于aop思想..
Spring声明式事务管理(XML与注解方式)
吃果冻不吐果冻皮
11-16 5091
事务控制概述编程式事务控制自己手动控制事务，就叫做编程式事务控制。 Jdbc代码： Conn.setAutoCommite(false); // 设置手动控制事务 Hibernate代码： Session.beginTransaction(); // 开启一个事务细粒度的事务控制： 可以对指定的方法、指定的方法的某几行添加事务控制。(比较灵活，但开发起来比较繁琐： 每次都要开启、提
Spring事务-基于xml和注解
weixin_42067668的博客
03-28 325
事务应该有aop, 步骤是 事务管理器配置（这个事务管理器是spring提供的） 配置事务的通知 <tx:advice id="txadvice" transection-manager = "transectionManager"> 配置aop <aop:config> //配置切入点表达式 <aop:pointcut id="pt1" expre...
mysql 不支持utf8mb4_0900_ai_ci
最新发布
green hand的博客
10-14 274
表示它支持最多4个字节的字符，这使得它能够存储比传统 UTF-8 更多的字符。它是 MySQL 5.5.3 及以后版本推荐的字符集，因为它提供了更好的国际化支持和更广泛的字符支持。这种排序规则特别适合需要对包含字母和数字的字符串进行排序的场景，并且不区分大小写。utf8mb4_0900_ai_ci/utf8mb4_0900_ci 修改为utf8_general_ci。：这是一种超集（superset）的 UTF-8 编码，它支持存储任何Unicode字符，包括一些新的和罕见的字符。
SpringBoot注解方式实现声明式事务：告别XML
Spring Boot支持两种主要的事务类型：XML声明式事务管理和注解事务管理。XML声明式事务通过在`transaction.xml`文件中定义切入点（AOP）和事务管理规则来实现，例如定义切面（Aspect）和事务管理器。然而，随着...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值