手动提交事务

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());
    }


}