手动提交事务

最新推荐文章于 2024-01-26 22:24:43 发布
最新推荐文章于 2024-01-26 22:24:43 发布
阅读量3.6k 收藏 6
点赞数
文章标签： java 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_61503139/article/details/129185790
版权

1.

@Autowired
DataSource dataSource;
@Resource
private DataSourceTransactionManager dataSourceTransactionManager;
@Resource
private TransactionDefinition transactionDefinition;

//  @Transactional(rollbackFor = Exception.class)
  public Result findB00List(String b00) throws SQLException, IOException {
      TransactionStatus transactionStatus = dataSourceTransactionManager.getTransaction(transactionDefinition);
      //获取现在的时间
      LambdaQueryWrapper<Dict> wrapper = new LambdaQueryWrapper<>();
      wrapper.eq(Dict::getName,"dda");
      List<Dict> list = dictService.list(wrapper);
      Dict dict = new Dict();
      dict.setName("侧睡事务");
      dictService.save(dict);
      Long id = dict.getId();
      this.test666();

     // dataSourceTransactionManager.rollback(transactionStatus);
      dataSourceTransactionManager.commit(transactionStatus);

      wrapper.clear();

      wrapper.eq(Dict::getDate,new Date());

      List<Dict> list1 = dictService.list(wrapper);
      // 拷贝文件夹
 /*     File file1 = new File("E:\\test01");
      File file2 = new File("E:\\test02");
      FileUtils.copyDirectoryToDirectory(file1,file2);*/

      // 拷贝文件
    /*  File file3 = new File("E:\\test01\\mysql5.txt");
      File file4 = new File("E:\\test02");
      FileUtils.copyFileToDirectory(file3,file4);*/


   List<String>  B00List= dictService.findB00List(b00);

      return Result.ok(B00List);
  }
package com.atguigu.yygh.cmn.controller;

import cn.hutool.core.bean.BeanUtil;
import cn.hutool.core.date.DateTime;
import cn.hutool.core.date.DateUnit;
import cn.hutool.core.date.DateUtil;
import cn.hutool.core.io.FileUtil;
import cn.hutool.core.io.IoUtil;
import cn.hutool.core.io.file.FileReader;
import cn.hutool.core.util.IdUtil;
import cn.hutool.json.JSONUtil;
import com.alibaba.excel.EasyExcel;
import com.alibaba.excel.ExcelReader;
import com.alibaba.excel.read.metadata.ReadSheet;
import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONObject;
import com.atguigu.yygh.cmn.listener.DictListener;
import com.atguigu.yygh.cmn.listener.ExcelListener;
import com.atguigu.yygh.cmn.mapper.DictMapper;
import com.atguigu.yygh.cmn.service.DictService;
import com.atguigu.yygh.common.exception.GuliException;
import com.atguigu.yygh.common.result.Result;
import com.atguigu.yygh.common.result.ResultCodeEnum;
import com.atguigu.yygh.model.cmn.Dict;
import com.atguigu.yygh.vo.cmn.DictEeVo;
import com.atguigu.yygh.vo.cmn.ExpertVo;

import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.conditions.update.LambdaUpdateWrapper;
import com.baomidou.mybatisplus.core.conditions.update.UpdateWrapper;
import com.baomidou.mybatisplus.core.toolkit.Wrappers;
import com.github.pagehelper.PageInfo;
import generator.domain.cacheMap;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiOperation;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.io.FileUtils;
import org.apache.commons.io.FilenameUtils;
import org.apache.commons.lang3.StringUtils;
import org.apache.commons.lang3.math.NumberUtils;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.autoconfigure.data.redis.RedisProperties;
import org.springframework.data.redis.core.RedisTemplate;

import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.jdbc.datasource.DataSourceTransactionManager;
import org.springframework.transaction.TransactionDefinition;
import org.springframework.transaction.TransactionStatus;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.util.ObjectUtils;
import org.springframework.web.bind.annotation.*;
import org.springframework.web.multipart.MultipartFile;
import springfox.documentation.annotations.Cacheable;

import javax.annotation.Resource;
import javax.servlet.http.HttpServletResponse;
import javax.sql.DataSource;
import java.io.File;
import java.io.IOException;
import java.io.InputStream;
import java.sql.SQLException;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.time.format.DateTimeFormatter;
import java.util.*;
import java.util.concurrent.*;


@Api(description = "数据字典接口")
@RestController
@RequestMapping("/admin/cmn/dict")
//@CrossOrigin
@Slf4j
public class DictController {
    private Logger logger = LoggerFactory.getLogger(this.getClass());
    @Autowired
    private DictService dictService;
    @Autowired
    private DictMapper dictMapper;
    @Autowired
    private RedisTemplate<String,String> redisTemplate;
    @Autowired
    private JdbcTemplate jdbcTemplate;

    @Autowired
    DataSource dataSource;
    @Resource
    private DataSourceTransactionManager dataSourceTransactionManager;
    @Resource
    private TransactionDefinition transactionDefinition;

    /**
     * 线程池等待队列
     */
    private BlockingQueue<Runnable> workQueue = new ArrayBlockingQueue<>(30, true);

    /**
     * 自定义线程池
     */
    private ThreadPoolExecutor executor = new ThreadPoolExecutor(12, 20, 3, TimeUnit.SECONDS, workQueue);



    //导入数据字典
    @PostMapping("/importData")
    public Result importDict(MultipartFile file) {
        List<Dict> list = dictService.list();
        log.error("dada");
        logger.info("hahahhahahahahahhahahah" + "66666666666666666666");
        QueryWrapper<Dict> Wrapper = new QueryWrapper<>();
        Wrapper.eq("id", 1).eq("name", "哈哈");
        //Dict one = dictService.getOne(Wrapper);
        ObjectUtils.isEmpty(3);

        //logger.info(one.toString());

        dictService.importDictData(file);
        return Result.ok();
    }



    @PostMapping("/importDataStudent")
    public Result importDictStudent(MultipartFile file) throws IOException {

        dictService.importDictDataStudent(file);
        return Result.ok();
    }

    @PostMapping("/selectPage666")
    public Result selectPage666()  {
       // Map<String, Object> map = new cacheMap().getMap();
        Map<String, Object> map = cacheMap.map;
        if (map.containsKey("test")){
            System.out.println("jdjoajj");
        }

        return Result.ok();
    }

    @PostMapping("/selectPage")
    public Result selectPage(Integer page, Integer size) {
       /* redisTemplate.opsForValue().set("gag","hahah");
        String gag = redisTemplate.opsForValue().get("gag");
        System.out.println(gag);
        QueryWrapper<Dict> wrapper = new QueryWrapper<>();
        wrapper.select("name");
        List<Dict> list1 = dictService.list(wrapper);
        System.out.println(list1);
        PageInfo<Map<String, Object>> list = dictService.selectPage(page, size);*/
     /*   Dict dict = new Dict();
        dict.setName("9999");
        dict.setDate(new Date());
        boolean save = dictService.save(dict);

        Long id = dict.getId();
        System.out.println(id);*/
         //Map<String, Object> map = new cacheMap().getMap();
        Map<String, Object> map = cacheMap.map;
        map.put("test",111);
        map.put("test2",111);

        return Result.ok(ResultCodeEnum.DATA_ERROR);
    }

    @PostMapping("/Json")
    public Result Json(@RequestBody JSONObject object) {

       // Object o = object.get("Student");
        //List<Student> students1 = (List<Student>) object.get("Student");
       // System.out.println(students1);
        Student student1 = new Student();



       // String s = JSON.toJSONString(o);
        //List<Student> students = JSON.parseArray(s, Student.class);
       // System.out.println(students);
        // PageInfo<Map<String,Object>> list= dictService.selectPage(page,size);//[{"name":"展示呢","age":18},{"name":"展示呢","age":18},{"name":"展示呢","age":18}]
        String s2 = "[{\"name\":\"展示呢\",\"age\":18},{\"name\":\"展示呢\",\"age\":18},{\"name\":\"展示呢\",\"age\":18}]";
        return Result.ok();

    }



    //导出数据字典接口
    @GetMapping("exportData")

    public void exportDict(HttpServletResponse response) throws IOException {
        dictService.exportDictData(response);
    }

    @GetMapping("exportData1")
    public void exportDict1(HttpServletResponse response) throws IOException {
        dictService.exportDictData1(response);
    }

    @PostMapping("mapInsert")
    public void mapInsert()  {
        dictService.mapInsert();
    }


    @GetMapping("findDate")
    public Result findDate() throws IOException {
        QueryWrapper<Dict> borrowerQueryWrapper = new QueryWrapper<>();
        borrowerQueryWrapper.select("date","name","id");
        //用MP查询指定的字段
        List<Object> objects = dictMapper.selectObjs(borrowerQueryWrapper);
        List<Map<String, Object>> mapList = dictMapper.selectMaps(borrowerQueryWrapper);
        //查询全部
        List<Dict> list = dictMapper.selectList(null);
        String s = JSONObject.toJSONString(list);
        redisTemplate.opsForValue().set("key1",s);
        String key1 = redisTemplate.opsForValue().get("key1");
        List<Dict> dicts = JSONObject.parseArray(key1, Dict.class);
        System.out.println(dicts);


        LambdaQueryWrapper<Dict> gbrm06LambdaQueryWrapper = Wrappers.lambdaQuery();

        gbrm06LambdaQueryWrapper.eq(Dict::getId, null);
        boolean remove = dictService.remove(gbrm06LambdaQueryWrapper);
        boolean b = dictService.removeById(null);
        dictService.list(null);


        //第一种更新方法 利用填充字段和 QueryWrapper来实现
        QueryWrapper<Dict> objectQueryWrapper = new QueryWrapper<>();
        objectQueryWrapper.in("id","12","13","32").eq("name","大大");
        Dict dict = new Dict();
        dict.setName("测试啊爱还好");
        dictMapper.update(dict,objectQueryWrapper);
        //第二种更新方法,直接用UpdateWrapper来搞
        UpdateWrapper<Dict> updateWrapper = new UpdateWrapper<>();
        updateWrapper.set("name","gagaga");
        dictMapper.update(null,updateWrapper);


        // List<Map<String,Object>> list = dictService.findDate();
        return Result.ok(mapList);
    }

    //根据dictCode获取下级节点
    @ApiOperation(value = "根据dictCode获取下级节点")
    @GetMapping("findByDictCode/{dictCode}")
    public Result findByDictCode(@PathVariable String dictCode) {
        List<Dict> list = dictService.findByDictCode(dictCode);

        return Result.ok(list);
    }

    //根据数据id查询子数据列表
    @ApiOperation(value = "根据数据id查询子数据列表")
    @GetMapping("findChildData/{id}")
    public Result findChildData(@PathVariable Long id) {
        List<Dict> list = dictService.findChlidData(id);
        return Result.ok(list);
    }

    @ApiOperation(value = "根据数据id查询子数据列表")
    @GetMapping("insertDate")
    public Result insertDate() {
        dictService.insertDate();
        return Result.ok();
    }

    @ApiOperation(value = "根据数据id查询子数据列表")
    @GetMapping("fenYe")
    public Result fenYe(@RequestBody Student student) {
        System.out.println("手打");
        PageInfo<Map<String,Object>> list= dictService.fenYe();
        return Result.ok(list);
    }

    @PostMapping("chaRu")
    public Result chaRu() {
        List<String> list = Arrays.asList("dada");
        HashMap<String, Object> map = new HashMap<>();
        map.put("age",199);
        dictService.chaRu(list,map);
        return Result.ok(list);
    }




    @PostMapping("findChildData1")
    public Result findChildData1(@RequestBody Map<String,Object> map) {
       /*    String s1=  jsonObject.get("hh").toString();
        String dict = JSON.toJSONString(jsonObject.get("dict"));
        List<Dict> list1 = JSON.parseArray(dict, Dict.class);

        System.out.println(list1);

String s2="[{\"id\":1,\"name\":\"liu\"},{\"id\":2,\"name\":\"liu1\"},{\"id\":3,\"name\":\"liu3\"}]";
        // List<Dict> list = dictService.findChlidData(2L);*/
        LambdaQueryWrapper<Dict> wrapper = new LambdaQueryWrapper<>();
        LambdaUpdateWrapper<Dict> wrapper1 = new LambdaUpdateWrapper<>();
        QueryWrapper<Dict> queryWrapper = new QueryWrapper<>();
        //queryWrapper.like("name",name);
        queryWrapper.select("name");

        //没有指定泛型类型得自己遍历强制转化
        List<Object> objects = dictService.listObjs(queryWrapper);

        //指定了查询出来为String泛型就不用转换了
        List<String> list1 = dictService.listObjs(queryWrapper,functionId ->
             functionId.toString()
        );
        System.out.println(list1);

        return Result.ok(list1);
    }




    //根据dictcode和value查询
    @GetMapping("getName/{dictCode}/{value}")
    public String getName(@PathVariable String dictCode,
                          @PathVariable String value) {

        String dictName = dictService.getDictName(dictCode,value);
        return dictName;
    }

    //根据value查询
    @GetMapping("getName/{value}")
    public String getName(@PathVariable String value) {
        String dictName = dictService.getDictName("",value);
        return dictName;
    }

    //根据value查询
    @GetMapping("getJson")
    @Cacheable(value = "dada")
    public Result getJson(String id) {
        System.out.println(DateUtil.formatTime(new Date()));
        HashMap<String, Object> expertInfoQueryMap = new HashMap<>();
        FileReader fileReader = new FileReader("E:\\BaiduNetdiskDownload\\医疗软件\\代码\\代码\\医疗\\yygh_parent\\service\\service_cmn\\src\\main\\java\\com\\atguigu\\yygh\\cmn\\controller"  + "/testsql.json");
        String result = fileReader.readString();
        cn.hutool.json.JSONObject jsonObject = JSONUtil.parseObj(result);
        Set<String> strings = jsonObject.keySet();
        //测试打印sql用的
        for (String s : strings) {
            String sql = jsonObject.getStr(s);
            System.out.println(sql);
        }
        strings.forEach(m -> {
            String sql = jsonObject.getStr(m);
            expertInfoQueryMap.put(m, jdbcTemplate.queryForList(sql, id));

        });
       // String dictName = dictService.getDictName("",value);
          return Result.ok(expertInfoQueryMap);
    }


    @PostMapping("/upload_folder")
    @CrossOrigin
    public String uploadFolder(MultipartFile[] folder) {
        String basePath = "E:\\html" + System.currentTimeMillis() + File.separator;
        try {
            FolderUtils.saveMultiFile(basePath, folder);
        } catch (Exception e) {
            return "error";
        }
        String returnPath = basePath.replace("\\", "/");
        //	if (returnPath.startsWith("D:/")) {		//根据个人需要，把返回的字符串前的盘符删掉
        //     return returnPath.substring(3);
        // }
        return returnPath;
    }

    @PostMapping("getNameUpdate")
    public String getNameUpdate(Date date,String date1) throws ParseException {
        //LambdaUpdateWrapperz中set的值为null,sql会执行这条命令,不忽略null
        /*if (1==1){
            throw new GuliException(200,"失败而");
        }*/
        LambdaUpdateWrapper<Dict> wrapper = new LambdaUpdateWrapper<>();
        wrapper.set(Dict::getName,"da").set(Dict::getDate,null).eq(Dict::getId,1);
        dictService.update(wrapper);

        //updateById会自动忽略null值
        Dict dict = new Dict();
        dict.setId(121L);
        dict.setName("8989");//加了报错
        dict.setDate(null);//加了报错
        dictService.updateById(dict);

        //第三种更新方式
        QueryWrapper<Dict> wrapper1 = new QueryWrapper<>();
        wrapper1.eq("id",2);
        dict.setDate(new Date());
        dictService.update(dict,wrapper1);

        //第四种更新方式
        UpdateWrapper<Dict> wrapper2 = new UpdateWrapper<>();
        wrapper2.set("date",null).eq("id",2).set("id",99999L);
        dictService.update(null,wrapper2);
        //获取当前yyyy-MM-dd格式的时间
        DateTime date3 = DateUtil.date();
        String s = DateUtil.formatDate(date3);

        String format = DateUtil.format(date, "yyyy-MM-dd");
        System.out.println(format);
        DateTime time = DateUtil.parse(format,"yyyy-MM-dd");

        DateTime date2 = DateUtil.parseDate(format);
        Date parse = new SimpleDateFormat("yyyy-MM-dd").parse(format);
        DateTime dateTime = DateUtil.beginOfDay(new Date());
        long betweenDay = DateUtil.between(DateUtil.beginOfDay(new Date()), parse, DateUnit.DAY, false);

        System.out.println(time);
        System.out.println("dada");
        if (1==1){throw new RuntimeException("啦啦啦啦德玛西亚!");}

       //dictService.getNameUpdate(map);
        dictService.removeByIds(Arrays.asList(1,2,3));
        ArrayList<Dict> list = new ArrayList<>();
        list.add(new Dict(32L,null,new Date()));
        list.add(new Dict(33L,null,new Date()));


        dictService.updateBatchById(list);
      //  dictService.updateBatchById(list);



        return "dictName";
    }

    @GetMapping("getNameUpdate1")
    public Map<String, Object> getNameUpdate1(@RequestBody Map<String, Object> map) {
        // 使用多线程提升数据获取速度，保证数据完整可靠
        ConcurrentMap<String, Object> result = new ConcurrentHashMap<>(5);
        List<Future<Object>> futures = new ArrayList<>();
        // 此处设置成final为了保证其他线程能够访问的到
       // final Gbrm06 gbrm06 = mapper.getPersonImportantData(globalId, meetType);
        final Student gbrm06 =new Student();
        logger.info("测试的第{}数据","99");

        // 如果未被逻辑删除，说明还在进行中，此时允许编辑
       /* result.put("readOnly",
                gbrm06.getDeleteflag()
                        .equals(1));*/
        // 获取基本信息的线程
        Callable<Object> getBaseInfoThread = new Callable<Object>() {
            @Override
            public Object call() throws Exception {
                gbrm06.getAge();
                result.put("key1","测试1");
                return true;
            }

        };
        // 获取会议意见
        Callable<Object> getDutyFlowThread = new Callable<Object>() {
            @Override
            public Object call() throws Exception {
                result.put("key2","测试2");
                return true;
            }
        };

        // 获取会议意见
        Callable<Object> getDutyFlowThread1 = new Callable<Object>() {
            @Override
            public Object call() throws Exception {
                result.put("key3","测试3");
                return true;
            }
        };
        // 线程执行
        //futures.add(executor.submit(getAnchorThread));
        futures.add(executor.submit(getBaseInfoThread));
       // futures.add(executor.submit(getCheckedInfosThread));
      //  futures.add(executor.submit(getMeetingContext));
        futures.add(executor.submit(getDutyFlowThread));
      //  futures.add(executor.submit(getAgreePeopleCount));
        futures.add(executor.submit(getDutyFlowThread1));

        try {
            for (Future<Object> future : futures) {
                future.get();
            }
        } catch (InterruptedException | ExecutionException e) {
            logger.error("等待线程执行完成异常, {}", e.getMessage());
            throw new RuntimeException("服务器异常");
        }

        return result;
    }
    @PostMapping("test/excel/import")
    public void modelImport(MultipartFile serviceFile) throws IOException {
        //输入流
        InputStream inputStream = serviceFile.getInputStream();
        //监视器
        ExcelListener listener = new ExcelListener();
        ExcelReader excelReader = EasyExcel.read(inputStream, listener).build();
        // 第一个sheet读取类型
        ReadSheet readSheet1 = EasyExcel.readSheet(0).head(DictEeVo.class).build();
        // 第二个sheet读取类型
        ReadSheet readSheet2 = EasyExcel.readSheet(1).head(ExpertVo.class).build();
        // 开始读取第一个sheet
        excelReader.read(readSheet1);
        //excel sheet0 信息
        List<Object> list = listener.getDatas();
        //List<object> 转 List<实体类>
        List<Dict> dtoList = new ArrayList<>();
        //List object for 转换 实体类
        for (Object objects : list) {
            DictEeVo dto = (DictEeVo) objects;
            Dict dict = new Dict();
            BeanUtil.copyProperties(dto,dict);
            dtoList.add(dict);
        }
        //List 转JOSN
        String json = JSON.toJSONString(dtoList);
        System.out.println("json = " + json);
        //保存第一个sheet页中的数据
        dictService.saveBatch(dtoList);
        // 清空之前的数据
        listener.getDatas().clear();

        // 开始读取第二个sheet
        excelReader.read(readSheet2);
        //excel sheet1 信息
        List<Object> entry = listener.getDatas();
        //copy上面作法

        //List<object> 转 List<实体类>
        List<Dict> dtoList22 = new ArrayList<>();
        //List object for 转换 实体类
        List<Dict> dtoList1 = new ArrayList<>();
        //List object for 转换 实体类
        for (Object objects : list) {
            ExpertVo dto = (ExpertVo) objects;
            Dict dict = new Dict();
            BeanUtil.copyProperties(dto,dict);
            dtoList1.add(dict);
        }


        //保存第二个sheet页中的数据
        dictService.saveBatch(dtoList1);
        //List 转JOSN
        String json1 = JSON.toJSONString(dtoList);
        System.out.println("json2222 = " + json1);

    }

    @PostMapping("/addKey")
    @CrossOrigin
    public String addKey(@RequestBody User user) throws SQLException {

        // 获取调用的数据库名称
        String schemaName = null;

            schemaName = dataSource.getConnection()
                    .getMetaData()
                    .getUserName();
//            schemaName = schemaName.substring(0, schemaName.indexOf("@"));
        System.out.println("大大"+schemaName);


        return "6666";
    }

    @PostMapping("/findB00List")
    @CrossOrigin
  //  @Transactional(rollbackFor = Exception.class)
    public Result findB00List(String b00) throws SQLException, IOException {
        TransactionStatus transactionStatus = dataSourceTransactionManager.getTransaction(transactionDefinition);
        //获取现在的时间
        LambdaQueryWrapper<Dict> wrapper = new LambdaQueryWrapper<>();
        wrapper.eq(Dict::getName,"dda");
        List<Dict> list = dictService.list(wrapper);
        Dict dict = new Dict();
        dict.setName("侧睡事务");
        dictService.save(dict);
        Long id = dict.getId();
        this.test666();

       // dataSourceTransactionManager.rollback(transactionStatus);
        dataSourceTransactionManager.commit(transactionStatus);

        wrapper.clear();

        wrapper.eq(Dict::getDate,new Date());

        List<Dict> list1 = dictService.list(wrapper);
        // 拷贝文件夹
   /*     File file1 = new File("E:\\test01");
        File file2 = new File("E:\\test02");
        FileUtils.copyDirectoryToDirectory(file1,file2);*/

        // 拷贝文件
      /*  File file3 = new File("E:\\test01\\mysql5.txt");
        File file4 = new File("E:\\test02");
        FileUtils.copyFileToDirectory(file3,file4);*/


     List<String>  B00List= dictService.findB00List(b00);

        return Result.ok(B00List);
    }
    @Transactional
    public void test666(){
        if (1==1){
            throw new RuntimeException("dada");
        }
        dictService.save(new Dict());
    }


}

 

Harbor Lau
关注
  • 0
    点赞
  • 踩
  • 6
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
mysql实现事务的提交与回滚的实例详解
12-15
最近要对数据库的数据进行一个定时迁移，为了防止在执行过程sql语句因为某些原因报错而导致数据转移混乱，因此要对我们的脚本加以事务进行控制。 首先我们建一张tran_test表 CREATE TABLE tran_test( f1 VARCHAR(10) NOT NULL, f2 INT(1) DEFAULT NULL, PRIMARY KEY (f1) )ENGINE=INNODB CHARSET=utf8 我想对tran_test插入两条数据，但是为了防止插入中报错，因此我要把插入语句控制在一个事务内。 这时候，如果你查一下有些人的文章，许多时候会给出你这么一条答案。 START TRA
springmvc mybatis 手动提交事务
u010486495的专栏
07-10 1万+
public void save(User user) { //获取Spring容器的对象 WebApplicationContext contextLoader = ContextLoader.getCurrentWebApplicationContext(); //1.获取事务控制管理器 DataSourceTransactionManager transactionManager =
mysql的事务是什么 mybatis框架中的事务配置 mybatis中的自动提交事务和手动提交事务 深入理解mybatis事务源码 通过对象的地址来理解mysbaits中的会话 对象的首地址
念兮为美
12-10 2003
mysql的事务是什么？mybatis框架中的如何配置事务？mybatis中的自动提交事务和手动提交事务的区别是什么？ 深入理解mybatis事务源码和通过对象的地址来理解mysbaits中的会话，同时，也解释了什么是对象引用的首地址...
spring手动开启、提交、回滚事务
雄安少爷的博客
04-13 1万+
spring配置文件： java文件中的使用： @Autowired private DataSourceTransactionManager transactionManager;  //1.获取事务定义 DefaultTransactionDefinition def = new DefaultTransaction
MyBatis Plus中的事务处理
My_wife_QBL的博客
01-04 3880
MyBatis Plus中的事务处理可以通过注解实现声明式事务，也可以通过进行编程式事务管理。选择合适的事务管理方式取决于实际业务需求和开发者的喜好。希望本文能够帮助你更好地理解在MyBatis Plus中进行事务处理的方法。
MyBatis-Plus
骑士梦的博客
09-12 4613
一、MyBatis-Plus 操作 二、MyBatis-Plus CRUD 操作 三、MyBatis-Plus 乐观锁 四、MyBatis-Plus 分页查询 五、MyBatis-Plus 性能分析 六、MyBatis-Plus 代码生成
Mybatis/Plus事务
myli92的博客
10-26 7819
EnableTransactionManagement和@Transactional注解都在spring-tx。mybatis-plus-boot-starter不需要进行依赖，因为它以及默认引入了sprint-tx。
Mybatis-Plus事务管理
ManonLiu
04-23 1万+
1.springboot使用事务需要引入sprint-tx,但是在结合mybatisplus时，mybatis-plus已经代为引入了， 2.在springboot的启动类或者某个@Configuration上，加上@EnableTransactionManagent开启事务的支持 3.在service中使用@Transactional就可以使用事务了，@Transactional添加在方法中，方法支持事务，如果将@Transactional添加在类上，则整个类的所有方法都默认支持事务 4.@Tra.
Springboot + Mybatis-plus事务管理
热门推荐
bugpool的博客
04-19 3万+
前言 上节完善了productInfo的CRUD功能，这节我们完善Order订单功能，比起productInfo，订单的功能需要 事务操作，保证多个数据库操作的原子性 vo变复杂了，因此需要dto做转换 事务 事务就是为了保证多次数据库操作的原子性。举个简单的例子 买商品第一步要扣钱，第二步要扣库存。如果没有事务，一旦第一步与第二步之间出现了异常，那么钱是扣了，库存却没变，这显然不符合业务场景...
mybatis-plus事务
enjoy.day
04-23 6417
1.开启事务支持 @EnableTransactionManagement //开启事务管理 @Configuration // 配置类 public class MybatisPlusConfig { // 1.乐观锁 @Bean public OptimisticLockerInterceptor optimisticLockerInterceptor(){ return new OptimisticLockerInterceptor(); } /
JAVA设置手动提交事务,回滚事务,提交事务的操作
08-19
JAVA设置手动提交事务、回滚事务、提交事务的操作详解 本文主要介绍了JAVA设置手动提交事务、回滚事务、提交事务的操作，涉及到事务的自动提交、手动提交、回滚和提交等操作。以下是对这些操作的详细解释和示例代码...
spring框架手动提交事务，jdbctample
04-03
注意：只是jdbc自带的jdbctample，不能 用于整合mybatis框架的事务，我整合了，事务不起作用！！！！ 按老师的说法是基于xml方式，但不准确，因为也用到了注解 <aop:aspectj-autoproxy proxy-target-class="true">...
javaweb 通过threadlocal 手动提交事务
03-03
javaweb 通过threadlocal 手动提交事务
JdbcTemplate的事务控制.docx
07-26
JdbcTemplate是spring-jdbc提供的数据库核心操作类，那对JdbcTemplate进行事务控制呢？
springboot配置手动提交_JAVA设置手动提交事务,回滚事务,提交事务的操作
weixin_39618597的博客
12-22 1931
我就废话不多说啦，还是直接看代码吧！/*** 设置数据库是否自动提交事务* @param flag* @throws SQLException*/public void setAutoCommit(boolean flag) throws SQLException {con.setAutoCommit(flag);}/*** 提交* @throws SQLException*/public voi...
springboot + mybatis手动提交事务
最新发布
I do more ，you do less
01-26 603
【代码】springboot + mybatis手动提交事务。
Mybatis 的事务控制
m0_67401606的博客
03-22 1091
事务：访问并可能更新数据库中各种数据项的一个程序执行单元(unit) 事务的四个特性：原子性、一致性、隔离性、持久性 不考虑隔离性的三个问题：丢失修改、不可重复读，读脏数据 解决办法：四种隔离级别 文章目录 一、Mybatis 的事务控制 二、Mybatis 自动提交事务的设置 一、Mybatis 的事务控制 在 JDBC 中我们可以通过手动方式将事务的提交改为手动方式，通过 setAutoCommit()方法就可以调整。通过 JDK 文档，我们找到该方法如下： 手动提交时： @Be
MyBatis学习总结（三）MyBatis 的连接池技术MyBatis 的事务控制手动提交事务MyBatis 的动态 SQL 语句MyBatis 多表查询一对一、多对一、一对多、多对多查询
long3359的博客
04-16 562
MyBatis学习总结（三）MyBatis 的连接池技术/MyBatis 的事务控制/手动提交事务/MyBatis 的动态 SQL 语句/MyBatis 多表查询/一对一、多对一、一对多、多对多查询 一、MyBatis 的连接池技术分类 连接池就是一个用于存储连接的容器。这个容器其实就是一个集合对象，该集合必须是线程安全的，不能两个线程同时拿到同一个连接。该集合还必须有队列的特性：先进先出（归还的连接放在连接池队列的末尾）。 我们在实际开发中都会使用数据库连接池，因为它可以减少我们获取连接所消耗的时间。
使用SpringBoot集成Mybatis或Mybatis-plus开启事务
weixin_62321552的博客
07-07 3621
1、首先添加添加事务的依赖，spring-tx 注：如果是mybatis-plus就不需要进行这个依赖的引入，其中以及进行了内置；这两个框架进行开启事务的区别就这里了2、开启使用事务，在Springboot的启动类上，或是某个配置类上添加注@EnableTransactionManagement 3、在具体要进行开始事务的类上或方法上添加注解@Transactional，这样就开启了事务 使用在不同位置的区别：......
springboot 手动提交事务
05-17
在 Spring Boot 中，我们通常使用注解声明式事务管理来自动提交或回滚事务。但是，有时候我们可能需要手动提交事务，比如在某些特殊情况下需要在多个事务中共享数据时。在这种情况下，我们可以使用编程式事务管理，手动提交事务。 下面是一个手动提交事务的示例代码： ```java @Service public class UserService { @Autowired private DataSource dataSource; public void updateUser(User user) { Connection conn = null; PreparedStatement pstmt = null; try { conn = dataSource.getConnection(); conn.setAutoCommit(false); // 关闭自动提交事务 pstmt = conn.prepareStatement("UPDATE user SET name = ? WHERE id = ?"); pstmt.setString(1, user.getName()); pstmt.setLong(2, user.getId()); pstmt.executeUpdate(); conn.commit(); // 手动提交事务 } catch (SQLException e) { if (conn != null) { try { conn.rollback(); // 回滚事务 } catch (SQLException ex) { ex.printStackTrace(); } } e.printStackTrace(); } finally { try { if (pstmt != null) { pstmt.close(); } if (conn != null) { conn.close(); } } catch (SQLException e) { e.printStackTrace(); } } } } ``` 在这个示例代码中，我们首先获取了一个数据库连接，并将自动提交事务功能关闭。然后执行了一个更新操作，并手动提交事务。如果发生异常，我们将回滚事务，否则关闭连接。 需要注意的是，手动提交事务的时候，必须先关闭自动提交事务功能，否则手动提交不会生效。同时，如果手动提交事务失败，需要进行回滚操作，否则事务就会处于未知状态，可能会影响后续的操作。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值