Spring事务控制

1.事务介绍

1.1什么是事务？

当你需要一次执行多条SQL语句时，可以使用事务。通俗一点说，如果这几条SQL语句全部执行成功，则才对数据库进行一次更新，如果有一条SQL语句执行失败，则这几条SQL语句全部不进行执行，这个时候需要用到事务。

回顾一下数据库事务的四大特性ACID：

原子性：（Atomicity）
       要么都执行，要么都不执行

一致性：（Consistency）
       事务前后的数据都是正确的

隔离性：（Isolation）
      事物之间相互隔离，互不干扰（并发执行的事务彼此无法看到对方的中间状态）

持久性：（Durability）
       事务一旦提交不可再回滚 

 1.2数据库本身控制事物

begin transaction；//1.本地数据库操作：张三减少金额//2.本地数据库操作：李四增加金额
rollback;
或
commit transation;

 1.3jdbc中使用事物

1.获取对数据库的连接

2.设置事务不自动提交（默认情况是自动提交的）

conn.setAutoCommit(false);   //其中conn是第一步获取的随数据库的连接对象。

  3.把想要一次性提交的几个sql语句用事务进行提交

try{Statement stmt = null; stmt =conn.createStatement(); stmt.executeUpdate(sql1); int a=6/0;stmt.executeUpdate(Sql2); . . . conn.commit();   //使用commit提交事务 
}

4.捕获异常，进行数据的回滚（回滚一般写在catch块中）

catch（Exception e） { ... conn.rollback(); 
}

2.转账案例

2.1创建工程 

2.2添加转账业务

 2.2.1mapper 

package com.by.mapper;import com.by.pojo.User;
import org.apache.ibatis.annotations.Param;public interface UserMapper {public void addUser(User user);void updateUserOutMoney(@Param("source") String source, @Param("money")float money);void updateUserInMoney(@Param("target") String target, @Param("money")float money);
}

xml

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapperPUBLIC "-//mybatis.org//DTD Mapper 3.0//EN""http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.by.mapper.UserMapper"><insert id="addUser" parameterType="com.by.pojo.User">insert into t_user(name,money) values(#{name},#{money})</insert><update id="updateUserOutMoney">update t_user set money=money-#{money} where name=#{source}</update><update id="updateUserInMoney" >update t_user set money=money+#{money} where name=#{target}</update>
</mapper>

2.2.2service

package com.by.service;import com.by.mapper.UserMapper;
import com.by.pojo.User;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.jdbc.datasource.DataSourceTransactionManager;
import org.springframework.stereotype.Service;
import org.springframework.transaction.TransactionStatus;
import org.springframework.transaction.support.DefaultTransactionDefinition;@Service
public class UserServiceImpl implements UserService{@Autowiredprivate UserMapper userMapper;@Overridepublic void addUser(User user){userMapper.addUser(user);}@Overridepublic void updateUser(String source, String target, Float money) {userMapper.updateUserOutMoney(source,money);
userMapper.updateUserInMoney(target,money);}}

 2.2.3测试

package com.by.web;import com.by.pojo.User;
import com.by.service.UserService;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;import javax.annotation.Resource;@RunWith(SpringJUnit4ClassRunner.class)//加载配置文件
@ContextConfiguration("classpath:applicationContext.xml")
public class Client {@Autowired
//    @Resource(name = "proxyUserService")
//@Qualifier("proxyUserService")private UserService userService;@Testpublic void addUser(){userService.addUser(new User("小龙女",4000F));userService.addUser(new User ("李莫愁",2000F));
}@Test
public void testUpdateUser(){userService.updateUser("张三丰","宋远桥",1F);
}
}

2.2.4结果

1.此时我们观察数据表里面的变化情况：  

转账是成功的，但是涉及到业务的问题，如果业务层实现类有其中一个环节出问题，都会导致灾难。

2.我们先把数据恢复到转账前。

现在我们故意模拟转账业务出现问题

 @Overridepublic void updateUser(String source, String target, Float money) {
//转出userMapper.updateUserOutMoney(source,money);//制造转账异常int a=6/0;//转入userMapper.updateUserInMoney(target,money);
}

 再来测试：

业务执行出错，但是！

这是因为：不满足事务的一致性（减钱的事务提交了，加钱的事务没有提交，甚至都没有执行到）。

3.Spring中事务控制的API介绍

  • 说明：

    • JavaEE体系进行分层开发，事务处理位于业务层，Spring提供了分层设计业务层的事务处理解决方案。

    • Spring框架为我们提供了一组事务控制的接口。具体在后面的小节介绍。这组接口是在spring-tx.RELEASE.jar中。

    • spring的事务控制都是基于AOP的，它既可以使用编程的方式实现，也可以使用配置的方式实现。我们学习的重点是使用配置的方式实现。

3.1PlatformTransactionManager

 此接口是spring的事务管理器，它里面提供了我们常用的操作事务的方法，源代码如下：

public interface PlatformTransactionManager { //开启事务  TransactionStatus getTransaction(TransactionDefinition definition) throws TransactionException; //提交事务void commit(TransactionStatus status) throws TransactionException; //回滚事务void rollback(TransactionStatus status) throws TransactionException;   
}

 真正管理事务的对象:

Spring为不同的orm框架提供了不同的PlatformTransactionManager接口实现类：

  • DataSourceTransactionManager：使用Spring JDBC或iBatis 进行持久化数据时使用

  • HibernateTransactionManager：使用Hibernate版本进行持久化数据时使用

3.2TransactionDefinition

 TransactionDefinition接口包含与事务属性相关的方法，源代码如下：

public interface TransactionDefinition {int PROPAGATION_REQUIRED = 0;int PROPAGATION_SUPPORTS = 1;int PROPAGATION_MANDATORY = 2;int PROPAGATION_REQUIRES_NEW = 3;int PROPAGATION_NOT_SUPPORTED = 4;int PROPAGATION_NEVER = 5;int PROPAGATION_NESTED = 6;int ISOLATION_DEFAULT = -1;int ISOLATION_READ_UNCOMMITTED = 1;int ISOLATION_READ_COMMITTED = 2;int ISOLATION_REPEATABLE_READ = 4;int ISOLATION_SERIALIZABLE = 8;int TIMEOUT_DEFAULT = -1;//传播行为int getPropagationBehavior();//隔离级别int getIsolationLevel();//事务超时int getTimeout();//是否只读boolean isReadOnly();
}

 TransactionDefinition 接口定义的事务规则包括：事务隔离级别、事务传播行为、事务超时、事务的只读、回滚规则属性，同时，Spring 还为我们提供了一个默认的实现类：DefaultTransactionDefinition，该类适用于大多数情况。如果该类不能满足需求，可以通过实现 TransactionDefinition 接口来实现自己的事务定义。

3.2.1事务隔离级别

 事务并发时的安全问题

  • 问题描述隔离级别
    脏读一个事务读取到另一个事务还未提交的数据read-commited
    不可重复读一个事务内多次读取一行数据的内容，其结果不一致repeatable-read
    幻读一个事务内多次读取一张表中的内容，其结果不一致serialized-read
  • Spring事务隔离级别（比数据库事务隔离级别多一个default）由低到高为：
  • 隔离级别
    ISOLATION_DEFAULT这是一个platfromtransactionmanager默认的隔离级别，使用数据库默认的事务隔离级别。
    ISOLATION_READ_UNCOMMITTED这是事务最低的隔离级别，会产生脏读，不可重复读和幻像读。
    ISOLATION_READ_COMMITTED这种事务隔离级别可以避免脏读出现，但是可能会出现不可重复读和幻像读。 Oracle数据库默认的隔离级别。
    ISOLATION_REPEATABLE_READ这种事务隔离级别可以防止脏读、不可重复读，但是可能出现幻像读。MySQL数据库默认的隔离级别。
    ISOLATION_SERIALIZABLE这是花费最高代价但是最可靠的事务隔离级别，事务被处理为顺序执行。除了防止脏读、不可重复读外，还避免了幻像读。

    3.2.2事务的传播行为

  • 什么是事务传播行为？

    事务传播行为（propagation behavior）指的就是当一个事务方法被另一个事务方法调用时，这个事务方法应该如何进行。 例如：methodA事务方法调用methodB事务方法时，methodB是继续在调用者methodA的事务中运行呢，还是为自己开启一个新事务运行，这就是由methodB的事务传播行为决定的。

  • Spring定义了七种传播行为：

  • 事务传播行为类型说明
    PROPAGATION_REQUIRED如果当前没有事务，就新建一个事务，如果已经存在一个事务中，加入到这个事务中。这是最常见的选择。
    PROPAGATION_SUPPORTS支持当前事务，如果当前没有事务，就以非事务方式执行。
    PROPAGATION_MANDATORY使用当前的事务，如果当前没有事务，就抛出异常。
    PROPAGATION_REQUIRES_NEW新建事务，如果当前存在事务，把当前事务挂起。
    PROPAGATION_NOT_SUPPORTED以非事务方式执行操作，如果当前存在事务，就把当前事务挂起。
    PROPAGATION_NEVER以非事务方式执行，如果当前存在事务，则抛出异常。
    PROPAGATION_NESTED如果当前存在事务，则在嵌套事务内执行。如果当前没有事务，则执行与REQUIRED类似的操作。

3.2.3事务超时 

  • timeout事务超时时间： 当前事务所需操作的数据被其他事务占用，则等待。

    • 100：自定义等待时间100（秒）。

    • -1：由数据库指定等待时间，默认值。（建议）

3.2.4读写性 

  • readonly 读写性

    • true：只读，可提高查询效率，适合查询

    • false：可读可写，适合增删改

3.2.5回滚规则 

  • TransactionAttribute
  • TransactionAttribute 的默认实现类是DefaultTransactionAttribute ，它同时继承了DefaultTransactionDefinition。在DefaultTransactionDefinition 的基础上增加了rollbackOn的实现，DefaultTransactionAttribute的实现指定了，当异常类型为unchecked exception 的情况下将回滚事务。

  • rollbackOn 回滚规则，可省略或设置 rollbackOn="Exception"

    • 如果事务中抛出 RuntimeException,则自动回滚

    • 如果事务中抛出 CheckException，不会自动回滚

3.3TransactionStatus

 PlatformTransactionManager.getTransaction(…) 方法返回一个 TransactionStatus 对象，该对象代表一个新的或已经存在的事务，源代码如下

public  interface TransactionStatus{boolean isNewTransaction();void setRollbackOnly();boolean isRollbackOnly();
}

 4.改造转账案例

4.1applicationContext.xml

<!--    事务管理器DataSourceTransactionManager:负责开启、提交、回滚事务--><bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager"><property name="dataSource" ref="dataSource"></property></bean>
<--  事务属性：DefaultTransactionDefinition:配置事务的属性--><bean id="transactionDefinition" class="org.springframework.transaction.support.DefaultTransactionDefinition">
<!--     isolationLevel:控制事务的隔离性，有默认值，默认值为DEFAULTpropagationBehavior:事务的传播行为，有默认值，默认值为REQUIREDreadOnly:只读性，有默认值，默认值为falsetimeout:事务超时，有默认值，默认永不超时--><property name="isolationLevelName" value="DEFAULT"></property><property name="propagationBehaviorName" value="REQUIRED"></property><property name="readOnly" value="false"></property><property name="timeout" value="-1"></property></bean>

 4.2service

@Service
public class UserServiceImpl implements UserService {@Autowiredprivate UserMapper userMapper;@Autowiredprivate TransactionDefinition txDefinition;@Autowiredprivate PlatformTransactionManager txManager;/*** 转账* @param source* @param target* @param money*/@Overridepublic void updateUser(String source, String target, Float money) {// 获取一个事务TransactionStatus txStatus = txManager.getTransaction(txDefinition);try {userMapper.updateUserOfSub(source, money);int a = 6/0;userMapper.updateUserOfAdd(target, money);//提交事务txManager.commit(txStatus);}catch (Exception e){//回滚事务txManager.rollback(txStatus);e.printStackTrace();}}
}

 4.3测试

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration("classpath:applicationContext.xml")//加载配置文件
public class ServiceTest {@Autowiredprivate UserService userService;/*** 转账业务*/@Testpublic void testUpdate(){userService.updateUser("张三丰","宋远桥",1F);}
}

 事务回滚：

满足执行：

  • 我们现在虽然实现了事务控制，但是代码非常的臃肿，我们可以使用动态代理简化代码

5.动态代理控制事务

 5.1factory 

我们创建一个工厂，专门用来给 Service 创建代理对象，如下：  

package com.by.factory;import com.by.service.UserService;
import com.by.service.UserServiceImpl;
import org.hamcrest.Factory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
import org.springframework.transaction.PlatformTransactionManager;
import org.springframework.transaction.TransactionDefinition;
import org.springframework.transaction.TransactionStatus;import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;/*** bean工厂*/
@Component
public class BeanFactory {@Autowiredprivate UserService userService;@Autowiredprivate TransactionDefinition txDefinition;@Autowiredprivate PlatformTransactionManager txManager;/*** 获得UserServiceImpl对象** @return*/public UserService getUserService() {return (UserService) Proxy.newProxyInstance(userService.getClass().getClassLoader(),userService.getClass().getInterfaces(),new InvocationHandler() {public Object invoke(Object proxy, Method method, Object[] args)throws Throwable {//开启事务TransactionStatus txStatus = txManager.getTransaction(txDefinition);try {method.invoke(userService, args);//提交事务txManager.commit(txStatus);} catch (Exception e) {//回滚事务txManager.rollback(txStatus);e.printStackTrace();}return null;}});}
}

 5.2applicationContext.xml

<!--    注入工厂生成代理UserService--><bean id="proxyUserService" factory-bean="beanFactory" factory-method="getUserService"></bean>

 5.3service

@Service
public class UserServiceImpl implements UserService {@Autowiredprivate UserMapper userMapper;/*** 转账* @param source* @param target* @param money*/@Overridepublic void updateUser(String source, String target, Float money) {userMapper.updateUserOfSub(source, money);int a = 6/0;userMapper.updateUserOfAdd(target, money);}
}

 5.4测试

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration("classpath:applicationContext.xml")
public class ServiceTest {@Autowired@Qualifier("proxyService")//注入代理对象private UserService userService;@Testpublic void testUpdate(){userService.updateUser("张三丰","宋远桥",1F);}
}

  • 事务回滚：

 6.Spring AOP控制事务

6.1导入schema约束

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

 6.2配置增强、切点、切面

<!--    增强：要做的事情。eg:日志、事务--><tx:advice id="txManager" transaction-manager="transactionManager"><!--        定义属性--><tx:attributes><tx:method name="get*" propagation="SUPPORTS" read-only="true"/><tx:method name="select*" propagation="SUPPORTS" read-only="true"/><tx:method name="*" /></tx:attributes></tx:advice><aop:config><!--    切点:实际要增强的方法--><aop:pointcut id="pointcut" expression="execution(* com.by.service.*.*(..))"/><!--    切面:将增强作用与切点上--><aop:advisor advice-ref="txManager" pointcut-ref="pointcut"></aop:advisor></aop:config>

 6.3测试

package com.by.web;import com.by.pojo.User;
import com.by.service.UserService;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;import javax.annotation.Resource;@RunWith(SpringJUnit4ClassRunner.class)//加载配置文件
@ContextConfiguration("classpath:applicationContext.xml")
public class Client {@Autowired
//    @Resource(name = "proxyUserService")
//@Qualifier("proxyUserService")private UserService userService;@Testpublic void addUser(){userService.addUser(new User("小龙女",4000F));userService.addUser(new User ("李莫愁",2000F));
}@Test
public void testUpdateUser(){userService.updateUser("张三丰","宋远桥",1F);
}
}

 事务回滚：

7.基于注解的AOP控制事务

7.1applicationContext.xml

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

 7.2service

package com.by.service;import com.by.mapper.UserMapper;
import com.by.pojo.User;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.jdbc.datasource.DataSourceTransactionManager;
import org.springframework.stereotype.Service;
import org.springframework.transaction.TransactionStatus;
import org.springframework.transaction.annotation.Isolation;
import org.springframework.transaction.annotation.Propagation;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.transaction.support.DefaultTransactionDefinition;@Service
public class UserServiceImpl implements UserService{@Autowiredprivate UserMapper userMapper;@Overridepublic void addUser(User user){userMapper.addUser(user);}@Transactional(isolation = Isolation.DEFAULT,propagation = Propagation.REQUIRED,timeout = -1,readOnly = false,rollbackFor = Exception.class)@Overridepublic void updateUser(String source, String target, Float money) {userMapper.updateUserOutMoney(source,money);//制造转账异常int a=6/0;//转入userMapper.updateUserInMoney(target,money);}}

7.3测试

package com.by.web;import com.by.pojo.User;
import com.by.service.UserService;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;import javax.annotation.Resource;@RunWith(SpringJUnit4ClassRunner.class)//加载配置文件
@ContextConfiguration("classpath:applicationContext.xml")
public class Client {@Autowired
//    @Resource(name = "proxyUserService")
//@Qualifier("proxyUserService")private UserService userService;@Testpublic void addUser(){userService.addUser(new User("小龙女",4000F));userService.addUser(new User ("李莫愁",2000F));
}@Test
public void testUpdateUser(){userService.updateUser("张三丰","宋远桥",1F);
}
}

事务回滚：

8.总结 

spring事务控制
    1、事务介绍
        1）什么是事务？
            执行多条sql，要么全部执行，要么全部回滚
        2）事务的特点
            原子性：事务是最小执行单位
            一致性：事务前后数据都是正确的
            隔离性：事务之间看不到彼此的中间状态
            持久性：事务一旦提交不可再回滚
        3）mysql控制事务
            START TRANSACTION;
                sql1;
                sql2;
            COMMIT 或 ROLLBACK;
        4）jdbc控制事务

            try{
                conn.setAutoCommit(false);
                ....
                conn.commit();
            }catch(Exception e){
                conn.rollback();
            }

 spring事务控制的api
    1、PlatformTransactionManager
        作用：是一个事务管理器，负责开启、提交或回滚事务
        实现类：DataSourceTransactionManager(sqlSession)
    2、TransactionDefinition
        作用：定义事务的属性
        实现类：DefaultTransactionDefinition
        属性：
            1）隔离级别【有默认值】
                DEFAULT：默认值，等价于REPEATABLE_READ
                READ_UNCOMMITTED    x         x              x
                READ_COMMITTED      脏读       x              x
                REPEATABLE_READ     脏读      不可重复度
                SERIALIZABLE        脏读      不可重复度       幻读
            2）事务的传播行为【有默认值】
                REQUIRED：默认值，methodB()会加入到methodA()事务中
            3）事务超时【有默认值】
                默认-1：永不超时
            4）是否只读【有默认值】
                readOnly = false：默认值，适用于增删改
                readOnly = true：不记录log(效率快)，适用于查询
            5）回滚规则
                可省略：运行时异常回滚，编译时异常不回滚
    3、TransactionStatus
        作用：代表一个事务

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.mzph.cn/news/607948.shtml

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈email:809451989@qq.com，一经查实，立即删除！

相关文章

window mysql5.7 搭建主从同步环境

window mysql5.7 搭建主从同步环境

window 搭建mysql5.7数据库 主从同步 主节点 配置文件my3308.cnf [mysql] # 设置mysql客户端默认字符集 default-character-setutf8mb4[mysqld] server-id8 #server-uuidbc701be9-ac71-11ee-9e35-b06ebf511956 log-binD:\mysql_5.7.19\mysql-5.7.19-winx64\mysql-bin binlog-…
阅读更多...
性能分析与调优: Linux 内存观测工具

性能分析与调优: Linux 内存观测工具

目录 一、实验 1.环境 2.vmstat 3.PSI 4.swapon 5.sar 6.slabtop 7.numstat 8.ps 9.top 10.pmap 11.perf 12.bpftrace 二、问题 1.接口读写报错 2.slabtop如何安装 3.numactl如何安装 4.numad启动服务与关闭NUMA 5. perf如何安装 6. kernel-lt-doc与kern…
阅读更多...
Vue3+Vite打包跨平台(七牛、阿里OSS)上传部署前端项目

Vue3+Vite打包跨平台(七牛、阿里OSS)上传部署前端项目

1、业务场景 阅读之前&#xff0c;想了解一下各位观众老爷们&#xff0c;你们公司的项目是怎么部署的&#xff1a; 1.本地打包手动上传服务器&#xff1b; 2.本地打包自动上传服务器&#xff1b; 3.代码仓库流水线自动构建&#xff1b; 4.其他…&#xff1b; 我们用的第3种部…
阅读更多...
前端中什么是DOM对象

前端中什么是DOM对象

DOM&#xff08;文档对象模型&#xff09;是一种编程接口&#xff0c;用于HTML和XML文档。它提供了一种将文档结构表示为树结构的方式&#xff0c;这使得程序和脚本能够动态地访问和更新文档的内容、结构和样式。 在前端开发中&#xff0c;DOM是非常重要的概念。当浏览器加载网…
阅读更多...
认知能力测验，⑥如何破解逻辑判断类测试题？

认知能力测验，⑥如何破解逻辑判断类测试题？

逻辑思维&#xff0c;是一个比较大的范围&#xff0c;在绝大多数的招聘中&#xff0c;认知能力测评形式多样&#xff0c;难度也较大&#xff0c;其中逻辑判断题型所涉及到的分类为&#xff1a;概念类、条件类、矛盾类、数字类、图形类等知识。比如奥数就是个好东西.....如果经历…
阅读更多...
Go语言日志美化库，slog使用指南

Go语言日志美化库，slog使用指南

Go语言日志美化库&#xff0c;slog使用指南 1.slog2.快速开始3.使用JSON格式4.Text格式化formatter 1.slog slog是Go 实现的一个易于使用的&#xff0c;易扩展、可配置的日志库 slog - github 控制台效果&#xff1a; 安装方式&#xff1a; go get github.com/gookit/slog2…
阅读更多...
RAG 最新最全资料整理

RAG 最新最全资料整理

最近在做RAG方面的工作。它山之石可以攻玉&#xff0c;做了一些调研&#xff0c;包含了OpenAi&#xff0c;百川&#xff0c;iki.ai为我们提供的一些实现方案。 本文以时间顺序&#xff0c;整理了最近最新最全的和RAG相关的资料。都是满满的干货&#xff0c;包含了RAG评测工具、…
阅读更多...
TOPS、MIPS、DMIPS、MFLOPS、吞吐量与推理效率

TOPS、MIPS、DMIPS、MFLOPS、吞吐量与推理效率

1.概述 在深度学习对应的神经推理中经常涉及几个重要概念&#xff0c;TOPS、MIPS、DMIPS&#xff0c;MFLOPS&#xff0c;下文对其做对比说明。 2.概念对比 2.1 MIPS Million Instructions Per Second的缩写&#xff0c;每秒处理的百万级的机器语言instructions。这是衡量处…
阅读更多...
【单片机】四种烧写方式简介

【单片机】四种烧写方式简介

目录 单片机的四种烧写方式简介 1.使用JTAG接口实现2.SWD接口烧录方式3.ISP烧写方式&#xff0c;用UART实现&#xff08;常用&#xff09;4.SWIM单总线下载方式 烧录方式基本介绍烧录方式详述 1、ISP&#xff1a;In System Programming2、IAP&#xff1a;In Applicatin Program…
阅读更多...
部分城市公交站点数据，Shp+excel格式数据，2020年，几何类型为点

部分城市公交站点数据，Shp+excel格式数据，2020年，几何类型为点

随着城市的发展和人口的增长&#xff0c;公共交通成为了人们出行的重要方式之一。而公交站点作为公共交通的重要组成部分&#xff0c;其数据信息的获取和分析对于城市规划和管理具有重要意义。 今天来分享一下部分城市公交站点数据&#xff1a; 首先先了解下该数据的基本信息 …
阅读更多...
报错解决：RuntimeError: Error building extension ‘bias_act_plugin‘

报错解决：RuntimeError: Error building extension ‘bias_act_plugin‘

系统&#xff1a; Ubuntu22.04&#xff0c; nvcc -V&#xff1a;11.8 &#xff0c; torch&#xff1a;2.0.0cu118 一&#xff1a;BUG内容 运行stylegan项目的train.py时遇到报错&#x1f447; Setting up PyTorch plugin "bias_act_plugin"... Failed! /home/m…
阅读更多...
使用 RaiseExceptionMeta 元类隐式装饰 Validator 类中的所有校验方法

使用 RaiseExceptionMeta 元类隐式装饰 Validator 类中的所有校验方法

目录 一、前置说明1、总体目录2、相关回顾3、本节目标 二、操作步骤1、项目目录2、代码实现3、测试代码4、日志输出 三、后置说明1、要点小结2、下节准备 一、前置说明 1、总体目录 《 pyparamvalidate 参数校验器&#xff0c;从编码到发布全过程》 2、相关回顾 使用 raise…
阅读更多...
Qt QLineEdit文本框控件

Qt QLineEdit文本框控件

文章目录 1 属性和方法1.1 占位字符串1.2 对齐方式1.3 回显模式1.4 读写控制1.5 格式控制1.6 信号和槽 2 实例2. 布局2.2 代码实现 QLineEdit 是Qt 中的文本框&#xff0c;准确地说是单行文本框&#xff0c;通常用于接受用户的输入。 比如用户输入用户名、密码等&#xff0c;都…
阅读更多...
ChatGPT付费创作系统V2.5.5独立版+前端

ChatGPT付费创作系统V2.5.5独立版+前端

ChatGPT付费创作系统V2.5.5版本优化了很多细节&#xff0c;功能增加增加长篇写作功能。该版本为编译版无开源&#xff0c;本版本特别处理了后台弹窗、暗链网址。特别优化了数据库。升级过程中未发现任何BUG&#xff0c;全新安装或者升级安装均未出现400或者500错误&#xff0c;…
阅读更多...
【数据结构专题】「延时队列算法」史上手把手带你认识一下数据结构的基本概念与术语

【数据结构专题】「延时队列算法」史上手把手带你认识一下数据结构的基本概念与术语

在本节中&#xff0c;我们将对一些概念和术语赋以确定的含义&#xff0c;以便与读者取得“共同的语言”。这些概念和术语将在以后的章节中多次出现。 数据 概念 数据(data) 是对客观事物的符号表示&#xff0c; 在计算机科学中是指所有能输人到计算机中并被计算机程序处理的…
阅读更多...
Python 工具 | conda 基本命令

Python 工具 | conda 基本命令

Hi&#xff0c;大家好&#xff0c;我是源于花海。本文主要了解 Python 的工具的 conda 相关的基本命令。Conda 是一个开源的软件包管理系统和环境管理系统&#xff0c;用于安装多个版本的软件包及其依赖关系&#xff0c;并在它们之间轻松切换。在Windows下&#xff0c;需要安装…
阅读更多...
Mobile Aloha 【软硬件原理+代码解析】

Mobile Aloha 【软硬件原理+代码解析】

1. Mobile ALOHA Hardware2. Imitation Learning3. Co-training with Static ALOHA Data4. Task Setting5. Experiments5.1 ACT5.2 对比ACT、Diffusion Policy和VINN 6. Software Code Analyze Mobile ALOHA: 利用低成本全身远程操作系统学习复杂的双手移动操作技能 [译] 硬件代…
阅读更多...
Elasticsearch基本操作之文档操作

Elasticsearch基本操作之文档操作

本文来说下Elasticsearch基本操作之文档操作 文章目录 文档概述创建文档示例创建文档(生成随机id)创建文档(自定义唯一性标识) 查看文档示例根据主键查看文档查看所有文档 修改文档示例全局修改文档局部修改文档 删除文档示例根据文档的唯一性标识删除文档条件删除文档 本文小结…
阅读更多...
【leetcode 447. 回旋镖的数量】审慎思考与推倒重来

【leetcode 447. 回旋镖的数量】审慎思考与推倒重来

447. 回旋镖的数量 题目描述 给定平面上 **n **对 互不相同 的点 points &#xff0c;其中 points[i] [xi, yi] 。回旋镖 是由点 (i, j, k) 表示的元组 &#xff0c;其中 i 和 j 之间的距离和 i 和 k 之间的欧式距离相等&#xff08;需要考虑元组的顺序&#xff09;。 返回平…
阅读更多...
Linux引导过程和服务

Linux引导过程和服务

一、Linux操作系统引导过程 1.引导过程 bios 加电自检——mbr——grub——加载内核——启动进程 加电后BIOS程序回自检硬件&#xff0c;硬件无故障后&#xff0c;会根据第一次启动项去找内核&#xff0c;一般来说第一启动项是硬盘&#xff0c;找到硬盘后&#xff0c;会根据mb…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023