事务

事务的理解

事务是访问数据库的一个操作序列，数据库应用系统通过事务集来完成对数据库的存取。事务的正确执行使得数据库从一种状态转换成另一种状态。
事务必须服从ISO/IEC所制定的ACID原则。ACID是原子性（atomicity）、一致性（consistency）、隔离性（isolation）和持久性（durability）的缩写事务必须服从ISO/IEC所制定的ACID原则。ACID是原子性（atomicity）、一致性（consistency）、隔离性（isolation）和持久性（durability）的缩写。

1. 原子性。即不可分割性，事务要么全部被执行，要么就全部不被执行。如果事务的所有子事务全部提交成功，则所有的数据库操作被提交，数据库状态发生转换；如果有子事务失败，则其他子事务的数据库操作被回滚，即数据库回到事务执行前的状态，不会发生状态转换。
2. 一致性。事务的执行使得数据库从一种正确状态转换成另一种正确状态。
3. 隔离性。在事务正确提交之前，不允许把该事务对数据的任何改变提供给任何其他事务，即在事务正确提交之前，它可能的结果不应显示给任何其他事务。

4. 持久性。事务正确提交后，其结果将永久保存在数据库中，即使在事务提交后有了其他故障，事务的处理结果也会得到保存。

   事务的使用

   Spring采用注解的方式控制事务，一般在service层面上进行事务的控制，控制事务的注解为@Transactional
   即在service层中需要控制事务的类（不是接口类，而是实现类）或者方法（要求是public方法）上添加注解@Transactional，系统设计要求尽量放在需要进行事务管理的方法上，而不是放在所有接口实现类上。
   只针对写操作，读操作就没必要了
   示例代码：

   /**
   * 事务控制在service层面
   * 加上注解：@Transactional，声明的方法就是一个独立的事务（有异常DB操作全部回滚）
   */
   @Transactional
   public void testTran() {
    JeecgDemo pp = new JeecgDemo();
    pp.setAge(1111);
    pp.setName("测试事务  小白兔 1");
    jeecgDemoMapper.insert(pp);
    JeecgDemo pp2 = new JeecgDemo();
    pp2.setAge(2222);
    pp2.setName("测试事务  小白兔 2");
    jeecgDemoMapper.insert(pp2);
    Integer.parseInt("hello");//自定义异常
    JeecgDemo pp3 = new JeecgDemo();
    pp3.setAge(3333);
    pp3.setName("测试事务  小白兔 3");
    jeecgDemoMapper.insert(pp3);
   }

   错误的使用

5. 接口中A、B两个方法，A无@Transactional标签，B有，上层通过A间接调用B，此时事务不生效。

6. 接口中异常（运行时异常）被捕获而没有被抛出。默认配置下，spring 只有在抛出的异常为运行时 unchecked 异常时才回滚该事务，也就是抛出的异常为RuntimeException 的子类(Errors也会导致事务回滚)，而抛出 checked 异常则不会导致事务回滚 。可通过 @Transactional rollbackFor进行配置。

7. 多线程下事务管理因为线程不属于 spring 托管，故线程不能够默认使用 spring 的事务,也不能获取spring 注入的 bean 。在被 spring 声明式事务管理的方法内开启多线程，多线程内的方法不被事务控制。一个使用了@Transactional 的方法，如果方法内包含多线程的使用，方法内部出现异常，不会回滚线程中调用方法的事务。

   @Transactional注解

   
   @Transactional 实质是使用了 JDBC 的事务来进行事务控制的，基于 Spring 的动态代理的机制

8. 事务开始时，通过AOP机制，生成一个代理connection对象，并将其放入 DataSource 实例的某个与 DataSourceTransactionManager 相关的某处容器中。在接下来的整个事务中，客户代码都应该使用该connection 连接数据库，执行所有数据库命令。[不使用该 connection 连接数据库执行的数据库命令，在本事务回滚的时候得不到回滚]（物理连接 connection 逻辑上新建一个会话session；DataSource 与TransactionManager 配置相同的数据源）

9. 事务结束时，回滚在第1步骤中得到的代理 connection 对象上执行的数据库命令，然后关闭该代理 connection 对象。（事务结束后，回滚操作不会对已执行完毕的SQL操作命令起作用）

@Transactional属性配置

字段说明：

1. value ：主要用来指定不同的事务管理器；主要用来满足在同一个系统中，存在不同的事务管理器。比如在Spring中，声明了两种事务管理器txManager1, txManager2。然后，用户可以根据这个参数来根据需要指定特定的txManager.
2. value 适用场景：在一个系统中，需要访问多个数据源或者多个数据库，则必然会配置多个事务管理器的
3. REQUIRED_NEW：内部的事务独立运行，在各自的作用域中，可以独立的回滚或者提交；而外部的事务将不受内部事务的回滚状态影响。
4. ESTED 的事务，基于单一的事务来管理，提供了多个保存点。这种多个保存点的机制允许内部事务的变更触发外部事务的回滚。而外部事务在混滚之后，仍能继续进行事务处理，即使部分操作已经被混滚。 由于这个设置基于 JDBC 的保存点，所以只能工作在 JDB C的机制。
5. rollbackFor：让受检查异常回滚；即让本来不应该回滚的进行回滚操作。
6. noRollbackFor：忽略非检查异常；即让本来应该回滚的不进行回滚操作。

多数据源的事务使用

# 数据源
spring:
    datasource:
       # master数据源配置
       mysql:
           driverClassName: com.mysql.jdbc.Driver
           url: jdbc:mysql://localhost:3306/test?useUnicode=true&characterEncoding=utf-8
           username: root
           password: root
       # cluster数据源配置
       oracle:
          driver-class-name: oracle.jdbc.driver.OracleDriver
            url: jdbc:oracle:thin:@localhost:1521:orcl 
          username: root
          password: root

根据不同的数据库创建对应的事务管理器

@Bean(name = "mysqlTransactionManager")  
@Bean(name = "oracleTransactionManager")

@Configuration
@MapperScan(basePackages = "com.spring.boot.mapper.mysql",sqlSessionTemplateRef = ",mysqlSqlSessionTemplate")
public class ClusterDataSourceConfig {
    /**
     * 创建数据源
     *@return DataSource
     */
    @Bean(name = "mysqlDataSource")
    @ConfigurationProperties(prefix = "spring.datasource.mysql")
    public DataSource masterDataSource() {
        return DataSourceBuilder.create().build();
    }
    /**
     * 创建工厂
     *@param dataSource
     *@throws Exception
     *@return SqlSessionFactory
     */
    @Bean(name = "mysqlSqlSessionFactory")
    public SqlSessionFactory masterSqlSessionFactory(@Qualifier("mysqlDataSource") DataSource dataSource) throws Exception {
        SqlSessionFactoryBean bean = new SqlSessionFactoryBean();
        bean.setDataSource(dataSource);
        bean.setMapperLocations(new PathMatchingResourcePatternResolver().getResources("classpath:mapper/mysql/*.xml"));
        return bean.getObject();
    }
    /**
     * 创建事务
     *@param dataSource
     *@return DataSourceTransactionManager
     */
    @Bean(name = "mysqlTransactionManager")
    public DataSourceTransactionManager masterDataSourceTransactionManager(@Qualifier("mysqlDataSource") DataSource dataSource) {
        return new DataSourceTransactionManager(dataSource);
    }
    /**
     * 创建模板
     *@param sqlSessionFactory  
     *@return SqlSessionTemplate
     */
    @Bean(name = "clusterSqlSessionTemplate")
    public SqlSessionTemplate masterSqlSessionTemplate(@Qualifier("clusterSqlSessionFactory") SqlSessionFactory sqlSessionFactory) {
        return new SqlSessionTemplate(sqlSessionFactory);
    }
}

@Configuration
@MapperScan(basePackages = "com.spring.boot.mapper.oracle",sqlSessionTemplateRef = "oracleSessionTemplate")
public class MasterDataSourceConfig {
    /**
     * 创建数据源
     *@return DataSource
     */
    @Bean(name = "oracleDataSource")
    @ConfigurationProperties(prefix = "spring.datasource.oracle")
    @Primary
    public DataSource masterDataSource() {
        return DataSourceBuilder.create().build();
    }
    /**
     * 创建工厂
     *@param dataSource
     *@throws Exception
     *@return SqlSessionFactory
     */
    @Bean(name = "oracleSessionFactory")
    @Primary
    public SqlSessionFactory masterSqlSessionFactory(@Qualifier("oracleDataSource") DataSource dataSource) throws Exception {
        SqlSessionFactoryBean bean = new SqlSessionFactoryBean();
        bean.setDataSource(dataSource);
        bean.setMapperLocations(new PathMatchingResourcePatternResolver().getResources("classpath:mapper/oracle/*.xml"));
        return bean.getObject();
    }
    /**
     * 创建事务
     *@param dataSource
     *@return DataSourceTransactionManager
     */
    @Bean(name = "oracleTransactionManager")
    @Primary
    public DataSourceTransactionManager masterDataSourceTransactionManager(@Qualifier("oracleDataSource") DataSource dataSource) {
        return new DataSourceTransactionManager(dataSource);
    }
    /**
     * 创建模板
     *@param sqlSessionFactory  
     *@return SqlSessionTemplate
     */
    @Bean(name = "oracleSessionTemplate")
    @Primary
    public SqlSessionTemplate masterSqlSessionTemplate(@Qualifier("oracleSessionFactory") SqlSessionFactory sqlSessionFactory) {
        return new SqlSessionTemplate(sqlSessionFactory);
    }
}

在service层添加@Transactional注解

@Transactional(readOnly = true,rollbackFor = Exception.class,transactionManager = "clusterTransactionManager",isolation = Isolation.READ_UNCOMMITTED,propagation = Propagation.REQUIRED)

拓展

在微服务架构中可使用springcloud alibaba中的微服务seata中的@GlobalTransactional注解，其功能和用法与@Transactional差不多，不过@GlobalTransactional是做全局事务控制的，而@Transactional是非全局的。

JeecgBoot的定时任务

不带参的任务

1. 首先新建一个任务类并实现Job接口，在其实现的方法上写上相应的任务，用于定时执行

示例代码：

/**
 * 示例不带参定时任务
 * 
 * @author Scott
 */
@Slf4j
public class SampleJob implements Job {
    @Override
    public void execute(JobExecutionContext jobExecutionContext) throws JobExecutionException {
       log.info(String.format(" Jeecg-Boot 普通定时任务 SampleJob !  时间:" + DateUtils.getTimestamp()));
    }
}

1. 然后进入JeecgBoot后台添加定时任务

1. 任务参数设置

带参的任务

/**
 * 示例带参定时任务
 * 
 * @Author Scott
 */
@Slf4j
public class SampleParamJob implements Job {
    /**
     * 若参数变量名修改 QuartzJobController中也需对应修改
     */
    private String parameter;
    public void setParameter(String parameter) {
        this.parameter = parameter;
    }
    @Override
    public void execute(JobExecutionContext jobExecutionContext) throws JobExecutionException {
        log.info(" Job Execution key："+jobExecutionContext.getJobDetail().getKey());
        log.info( String.format("welcome %s! Jeecg-Boot 带参数定时任务 SampleParamJob !   时间:" + DateUtils.now(), this.parameter));
    }
}

实现类

package org.jeecg.modules.quartz.service.impl;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import lombok.extern.slf4j.Slf4j;
import org.jeecg.common.constant.CommonConstant;
import org.jeecg.common.exception.JeecgBootException;
import org.jeecg.common.util.DateUtils;
import org.jeecg.modules.quartz.entity.QuartzJob;
import org.jeecg.modules.quartz.mapper.QuartzJobMapper;
import org.jeecg.modules.quartz.service.IQuartzJobService;
import org.quartz.*;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import java.util.Date;
import java.util.List;
/**
 * @Description: 定时任务在线管理
 * @Author: jeecg-boot
 * @Date: 2019-04-28
 * @Version: V1.1
 */
@Slf4j
@Service
public class QuartzJobServiceImpl extends ServiceImpl<QuartzJobMapper, QuartzJob> implements IQuartzJobService {
    @Autowired
    private QuartzJobMapper quartzJobMapper;
    @Autowired
    private Scheduler scheduler;
    /**
     * 立即执行的任务分组
     */
    private static final String JOB_TEST_GROUP = "test_group";
    @Override
    public List<QuartzJob> findByJobClassName(String jobClassName) {
        return quartzJobMapper.findByJobClassName(jobClassName);
    }
    /**
     * 保存&启动定时任务
     */
    @Override
    @Transactional(rollbackFor = JeecgBootException.class)
    public boolean saveAndScheduleJob(QuartzJob quartzJob) {
        // DB设置修改
        quartzJob.setDelFlag(CommonConstant.DEL_FLAG_0);
        boolean success = this.save(quartzJob);
        if (success) {
            if (CommonConstant.STATUS_NORMAL.equals(quartzJob.getStatus())) {
                // 定时器添加
                this.schedulerAdd(quartzJob.getId(), quartzJob.getJobClassName().trim(), quartzJob.getCronExpression().trim(), quartzJob.getParameter());
            }
        }
        return success;
    }
    /**
     * 恢复定时任务
     */
    @Override
    @Transactional(rollbackFor = JeecgBootException.class)
    public boolean resumeJob(QuartzJob quartzJob) {
        schedulerDelete(quartzJob.getId());
        schedulerAdd(quartzJob.getId(), quartzJob.getJobClassName().trim(), quartzJob.getCronExpression().trim(), quartzJob.getParameter());
        quartzJob.setStatus(CommonConstant.STATUS_NORMAL);
        return this.updateById(quartzJob);
    }
    /**
     * 编辑&启停定时任务
     * @throws SchedulerException 
     */
    @Override
    @Transactional(rollbackFor = JeecgBootException.class)
    public boolean editAndScheduleJob(QuartzJob quartzJob) throws SchedulerException {
        if (CommonConstant.STATUS_NORMAL.equals(quartzJob.getStatus())) {
            schedulerDelete(quartzJob.getId());
            schedulerAdd(quartzJob.getId(), quartzJob.getJobClassName().trim(), quartzJob.getCronExpression().trim(), quartzJob.getParameter());
        }else{
            scheduler.pauseJob(JobKey.jobKey(quartzJob.getId()));
        }
        return this.updateById(quartzJob);
    }
    /**
     * 删除&停止删除定时任务
     */
    @Override
    @Transactional(rollbackFor = JeecgBootException.class)
    public boolean deleteAndStopJob(QuartzJob job) {
        schedulerDelete(job.getId());
        boolean ok = this.removeById(job.getId());
        return ok;
    }
    @Override
    public void execute(QuartzJob quartzJob) throws Exception {
        String jobName = quartzJob.getJobClassName().trim();
        Date startDate = new Date();
        String ymd = DateUtils.date2Str(startDate,DateUtils.yyyymmddhhmmss.get());
        String identity =  jobName + ymd;
        //3秒后执行 只执行一次
        // update-begin--author:sunjianlei ---- date:20210511--- for：定时任务立即执行，延迟3秒改成0.1秒-------
        startDate.setTime(startDate.getTime() + 100L);
        // update-end--author:sunjianlei ---- date:20210511--- for：定时任务立即执行，延迟3秒改成0.1秒-------
        // 定义一个Trigger
        SimpleTrigger trigger = (SimpleTrigger)TriggerBuilder.newTrigger()
                .withIdentity(identity, JOB_TEST_GROUP)
                .startAt(startDate)
                .build();
        // 构建job信息
        JobDetail jobDetail = JobBuilder.newJob(getClass(jobName).getClass()).withIdentity(identity).usingJobData("parameter", quartzJob.getParameter()).build();
        // 将trigger和 jobDetail 加入这个调度
        scheduler.scheduleJob(jobDetail, trigger);
        // 启动scheduler
        scheduler.start();
    }
    @Override
    @Transactional(rollbackFor = JeecgBootException.class)
    public void pause(QuartzJob quartzJob){
        schedulerDelete(quartzJob.getId());
        quartzJob.setStatus(CommonConstant.STATUS_DISABLE);
        this.updateById(quartzJob);
    }
    /**
     * 添加定时任务
     *
     * @param jobClassName
     * @param cronExpression
     * @param parameter
     */
    private void schedulerAdd(String id, String jobClassName, String cronExpression, String parameter) {
        try {
            // 启动调度器
            scheduler.start();
            // 构建job信息
            JobDetail jobDetail = JobBuilder.newJob(getClass(jobClassName).getClass()).withIdentity(id).usingJobData("parameter", parameter).build();
            // 表达式调度构建器(即任务执行的时间)
            CronScheduleBuilder scheduleBuilder = CronScheduleBuilder.cronSchedule(cronExpression);
            // 按新的cronExpression表达式构建一个新的trigger
            CronTrigger trigger = TriggerBuilder.newTrigger().withIdentity(id).withSchedule(scheduleBuilder).build();
            scheduler.scheduleJob(jobDetail, trigger);
        } catch (SchedulerException e) {
            throw new JeecgBootException("创建定时任务失败", e);
        } catch (RuntimeException e) {
            throw new JeecgBootException(e.getMessage(), e);
        }catch (Exception e) {
            throw new JeecgBootException("后台找不到该类名：" + jobClassName, e);
        }
    }
    /**
     * 删除定时任务
     * 
     * @param id
     */
    private void schedulerDelete(String id) {
        try {
            scheduler.pauseTrigger(TriggerKey.triggerKey(id));
            scheduler.unscheduleJob(TriggerKey.triggerKey(id));
            scheduler.deleteJob(JobKey.jobKey(id));
        } catch (Exception e) {
            log.error(e.getMessage(), e);
            throw new JeecgBootException("删除定时任务失败");
        }
    }
    private static Job getClass(String classname) throws Exception {
        Class<?> class1 = Class.forName(classname);
        return (Job) class1.newInstance();
    }
}

Cron表达式

七个参数，从第一个到最后一个分表表示秒、分、时、日、月、周、年
-：区间
/：循环
,：第几
?：不设置
*：每
日和周只能设置其中之一

JeecgBoot的系统通知接口

短信通知接口

DySmsHelper.sendSms(mobile, obj,DySmsEnum.REGISTER_TEMPLATE_CODE)
mobile：短信接收方的手机号
obj：模板中的变量替换JSON串,如模板内容为”亲爱的${name},您的验证码为${code}”
DySmsEnum.REGISTER_TEMPLATE_CODE：枚举类中的变量，包含短信签名(signName)、短信模板code(templateCode)、短信模板必需的数据名称(keys)，多个key以逗号分隔
需要注意的是这里的签名和code是短信服务里的，而不是下图中的code，目前jeecgboot使用的短信服务是阿里的

/**
 * Created on 17/6/7.
 * 短信API产品的DEMO程序,工程中包含了一个SmsDemo类，直接通过
 * 执行main函数即可体验短信产品API功能(只需要将AK替换成开通了云通信-短信产品功能的AK即可)
 * 工程依赖了2个jar包(存放在工程的libs目录下)
 * 1:aliyun-java-sdk-core.jar
 * 2:aliyun-java-sdk-dysmsapi.jar
 *
 * 备注:Demo工程编码采用UTF-8
 * 国际短信发送请勿参照此DEMO
 */
public class DySmsHelper {
    private final static Logger logger=LoggerFactory.getLogger(DySmsHelper.class);
    //产品名称:云通信短信API产品,开发者无需替换
    static final String product = "Dysmsapi";
    //产品域名,开发者无需替换
    static final String domain = "dysmsapi.aliyuncs.com";
    // TODO 此处需要替换成开发者自己的AK(在阿里云访问控制台寻找)
    static  String accessKeyId;
    static  String accessKeySecret;
    public static void setAccessKeyId(String accessKeyId) {
        DySmsHelper.accessKeyId = accessKeyId;
    }
    public static void setAccessKeySecret(String accessKeySecret) {
        DySmsHelper.accessKeySecret = accessKeySecret;
    }
    public static String getAccessKeyId() {
        return accessKeyId;
    }
    public static String getAccessKeySecret() {
        return accessKeySecret;
    }
    public static boolean sendSms(String phone,JSONObject templateParamJson,DySmsEnum dySmsEnum) throws ClientException {
        //可自助调整超时时间
        System.setProperty("sun.net.client.defaultConnectTimeout", "10000");
        System.setProperty("sun.net.client.defaultReadTimeout", "10000");
        //update-begin-author：taoyan date:20200811 for:配置类数据获取
        StaticConfig staticConfig = SpringContextUtils.getBean(StaticConfig.class);
        setAccessKeyId(staticConfig.getAccessKeyId());
        setAccessKeySecret(staticConfig.getAccessKeySecret());
        //update-end-author：taoyan date:20200811 for:配置类数据获取
        //初始化acsClient,暂不支持region化
        IClientProfile profile = DefaultProfile.getProfile("cn-hangzhou", accessKeyId, accessKeySecret);
        DefaultProfile.addEndpoint("cn-hangzhou", "cn-hangzhou", product, domain);
        IAcsClient acsClient = new DefaultAcsClient(profile);
        //验证json参数
        validateParam(templateParamJson,dySmsEnum);
        //组装请求对象-具体描述见控制台-文档部分内容
        SendSmsRequest request = new SendSmsRequest();
        //必填:待发送手机号
        request.setPhoneNumbers(phone);
        //必填:短信签名-可在短信控制台中找到
        request.setSignName(dySmsEnum.getSignName());
        //必填:短信模板-可在短信控制台中找到
        request.setTemplateCode(dySmsEnum.getTemplateCode());
        //可选:模板中的变量替换JSON串,如模板内容为"亲爱的${name},您的验证码为${code}"时,此处的值为
        request.setTemplateParam(templateParamJson.toJSONString());
        //选填-上行短信扩展码(无特殊需求用户请忽略此字段)
        //request.setSmsUpExtendCode("90997");
        //可选:outId为提供给业务方扩展字段,最终在短信回执消息中将此值带回给调用者
        //request.setOutId("yourOutId");
        boolean result = false;
        //hint 此处可能会抛出异常，注意catch
        SendSmsResponse sendSmsResponse = acsClient.getAcsResponse(request);
        logger.info("短信接口返回的数据----------------");
        logger.info("{Code:" + sendSmsResponse.getCode()+",Message:" + sendSmsResponse.getMessage()+",RequestId:"+ sendSmsResponse.getRequestId()+",BizId:"+sendSmsResponse.getBizId()+"}");
        if ("OK".equals(sendSmsResponse.getCode())) {
            result = true;
        }
        return result;
    }
    private static void validateParam(JSONObject templateParamJson,DySmsEnum dySmsEnum) {
        String keys = dySmsEnum.getKeys();
        String [] keyArr = keys.split(",");
        for(String item :keyArr) {
            if(!templateParamJson.containsKey(item)) {
                throw new RuntimeException("模板缺少参数："+item);
            }
        }
    }
//    public static void main(String[] args) throws ClientException, InterruptedException {
//        JSONObject obj = new JSONObject();
//        obj.put("code", "1234");
//        sendSms("13800138000", obj, DySmsEnum.FORGET_PASSWORD_TEMPLATE_CODE);
//    }
}

邮件通知接口

JavaMailSender mailSender = (JavaMailSender) SpringContextUtils.getBean("mailSender");
SimpleMailMessage message = new SimpleMailMessage();
// 设置发送方邮箱地址
message.setFrom(emailFrom);//发件人邮箱
message.setTo(es_receiver);//收件人邮箱
message.setSubject(es_title);//标题
message.setText(es_content);//内容
mailSender.send(message);

或者

EmailSendMsgHandle emailSendMsgHandle = new EmailSendMsgHandle();
String es_receiver = "rongcw@upcif.com";
String es_title = "jeecg测试邮件";
String es_content = "测试内容";
emailSendMsgHandle.SendMsg(es_receiver ,es_title ,es_content );

系统消息提醒

调用ISysBaseAPI接口发送系统消息，message中发送方和接收方为系统用户的账户名

/**
     * 1发送系统消息
     * @param message 使用构造器赋值参数 如果不设置category(消息类型)则默认为2 发送系统消息
     */
    void sendSysAnnouncement(MessageDTO message);
    /**
     * 2发送消息 附带业务参数
     * @param message 使用构造器赋值参数
     */
    void sendBusAnnouncement(BusMessageDTO message);
    /**
     * 3通过模板发送消息
     * @param message 使用构造器赋值参数
     */
    void sendTemplateAnnouncement(TemplateMessageDTO message);
    /**
     * 4通过模板发送消息 附带业务参数
     * @param message 使用构造器赋值参数
     */
    void sendBusTemplateAnnouncement(BusTemplateMessageDTO message);
    /**
     * 5通过消息中心模板，生成推送内容
     * @param templateDTO 使用构造器赋值参数
     * @return
     */
    String parseTemplateByCode(TemplateDTO templateDTO);

MessageDTO message2 = new MessageDTO();
message2.setFromUser("jeecg");
message2.setToUser("admin,张小红");
message2.setTitle("测试");
try {
    sysBaseAPI.sendSysAnnouncement(message2);
    //sysBaseAPI.sendTemplateAnnouncement(message);
}catch (Exception e){
    e.printStackTrace();
}

也可通过模板进行系统消息发送

TemplateMessageDTO message = new TemplateMessageDTO();
HashMap<String,String> map = new HashMap<String,String>();                  
map.put("code","78946");                                                    
message.setTemplateCode("SMS_TEST"); //模板code                                       
message.setFromUser("jeecg");                                                 
message.setToUser("admin,张小红");                                             
message.setTemplateParam(map);
try {                                            
    sysBaseAPI.sendTemplateAnnouncement(message);
}catch (Exception e){                            
    e.printStackTrace();                         
}

public void sendTemplateAnnouncement(TemplateMessageDTO message) {
        String templateCode = message.getTemplateCode();
        String title = message.getTitle();
        Map<String,String> map = message.getTemplateParam();
        String fromUser = message.getFromUser();
        String toUser = message.getToUser();
        List<SysMessageTemplate> sysSmsTemplates = sysMessageTemplateService.selectByCode(templateCode);
        if(sysSmsTemplates==null||sysSmsTemplates.size()==0){
            throw new JeecgBootException("消息模板不存在，模板编码："+templateCode);
        }
        SysMessageTemplate sysSmsTemplate = sysSmsTemplates.get(0);
        //模板标题
        title = title==null?sysSmsTemplate.getTemplateName():title;
        //模板内容
        String content = sysSmsTemplate.getTemplateContent();
        if(map!=null) {
            for (Map.Entry<String, String> entry : map.entrySet()) {
                String str = "${" + entry.getKey() + "}";
                if(oConvertUtils.isNotEmpty(title)){
                    title = title.replace(str, entry.getValue());
                }
                content = content.replace(str, entry.getValue());
            }
        }
        SysAnnouncement announcement = new SysAnnouncement();
        announcement.setTitile(title);
        announcement.setMsgContent(content);
        announcement.setSender(fromUser);
        announcement.setPriority(CommonConstant.PRIORITY_M);
        announcement.setMsgType(CommonConstant.MSG_TYPE_UESR);
        announcement.setSendStatus(CommonConstant.HAS_SEND);
        announcement.setSendTime(new Date());
        announcement.setMsgCategory(CommonConstant.MSG_CATEGORY_2);
        announcement.setDelFlag(String.valueOf(CommonConstant.DEL_FLAG_0));
        sysAnnouncementMapper.insert(announcement);
        // 2.插入用户通告阅读标记表记录
        String userId = toUser;
        String[] userIds = userId.split(",");
        String anntId = announcement.getId();
        for(int i=0;i<userIds.length;i++) {
            if(oConvertUtils.isNotEmpty(userIds[i])) {
                SysUser sysUser = userMapper.getUserByName(userIds[i]);
                if(sysUser==null) {
                    continue;
                }
                SysAnnouncementSend announcementSend = new SysAnnouncementSend();
                announcementSend.setAnntId(anntId);
                announcementSend.setUserId(sysUser.getId());
                announcementSend.setReadFlag(CommonConstant.NO_READ_FLAG);
                sysAnnouncementSendMapper.insert(announcementSend);
                JSONObject obj = new JSONObject();
                obj.put(WebsocketConst.MSG_CMD, WebsocketConst.CMD_USER);
                obj.put(WebsocketConst.MSG_USER_ID, sysUser.getId());
                obj.put(WebsocketConst.MSG_ID, announcement.getId());
                obj.put(WebsocketConst.MSG_TXT, announcement.getTitile());
                webSocket.sendMessage(sysUser.getId(), obj.toJSONString());
            }
        }
        try {
            // 同步企业微信、钉钉的消息通知
            dingtalkService.sendActionCardMessage(announcement, true);
            wechatEnterpriseService.sendTextCardMessage(announcement, true);
        } catch (Exception e) {
            log.error("同步发送第三方APP消息失败！", e);
        }
    }

JeecgBoot的消息推送接口

JeecgBoot提供了根据消息模板实现消息推送的功能，类似消息中间件功能，数据推送添加至消息表中，定时任务自动推送。

使用步骤

1. 在消息中心-模板管理中创建所需模板

1. 引入推送工具类

org.jeecg.modules.message.util.PushMsgUtil.java

1. 调用接口推送消息

//当模板内容中有参数时，需添加map为内容中参数赋值，如果模板消息中没有参数，可省略

Map<String, String> map = new HashMap();
map.put("bpm_name","请假审批");
map.put("bpm_task","部门经理审批");
map.put("remark","");
//调用消息推送保存接口
boolean is_sendSuccess = pushMsgUtil.sendMessage("2", "789456", map,"rongcw@upcif.com");

参数说明：

需要注意的是，这里的receiver接收人，以什么样的消息类型就填写什么样的方式，比如邮箱类型的就填邮箱，否则会失败。
消息保存后之后，需要在定时任务中启动消息发送任务，才可进一步发送消息

package org.jeecg.modules.message.job;
import java.util.List;
import org.jeecg.common.util.DateUtils;
import org.jeecg.modules.message.entity.SysMessage;
import org.jeecg.modules.message.handle.ISendMsgHandle;
import org.jeecg.modules.message.handle.enums.SendMsgStatusEnum;
import org.jeecg.modules.message.handle.enums.SendMsgTypeEnum;
import org.jeecg.modules.message.service.ISysMessageService;
import org.quartz.Job;
import org.quartz.JobExecutionContext;
import org.quartz.JobExecutionException;
import org.springframework.beans.factory.annotation.Autowired;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import lombok.extern.slf4j.Slf4j;
/**
 * 发送消息任务
 */
@Slf4j
public class SendMsgJob implements Job {
    @Autowired
    private ISysMessageService sysMessageService;
    @Override
    public void execute(JobExecutionContext jobExecutionContext) throws JobExecutionException {
        log.info(String.format(" Jeecg-Boot 发送消息任务 SendMsgJob !  时间:" + DateUtils.getTimestamp()));
        // 1.读取消息中心数据，只查询未发送的和发送失败不超过次数的
        QueryWrapper<SysMessage> queryWrapper = new QueryWrapper<SysMessage>();
        queryWrapper.eq("es_send_status", SendMsgStatusEnum.WAIT.getCode())
                .or(i -> i.eq("es_send_status", SendMsgStatusEnum.FAIL.getCode()).lt("es_send_num", 6));
        List<SysMessage> sysMessages = sysMessageService.list(queryWrapper);
        System.out.println(sysMessages);
        // 2.根据不同的类型走不通的发送实现类
        for (SysMessage sysMessage : sysMessages) {
            ISendMsgHandle sendMsgHandle = null;
            try {
                if (sysMessage.getEsType().equals(SendMsgTypeEnum.EMAIL.getType())) {
                    sendMsgHandle = (ISendMsgHandle) Class.forName(SendMsgTypeEnum.EMAIL.getImplClass()).newInstance();
                } else if (sysMessage.getEsType().equals(SendMsgTypeEnum.SMS.getType())) {
                    sendMsgHandle = (ISendMsgHandle) Class.forName(SendMsgTypeEnum.SMS.getImplClass()).newInstance();
                } else if (sysMessage.getEsType().equals(SendMsgTypeEnum.WX.getType())) {
                    sendMsgHandle = (ISendMsgHandle) Class.forName(SendMsgTypeEnum.WX.getImplClass()).newInstance();
                }
            } catch (Exception e) {
                log.error(e.getMessage(),e);
            }
            Integer sendNum = sysMessage.getEsSendNum();
            try {
                sendMsgHandle.SendMsg(sysMessage.getEsReceiver(), sysMessage.getEsTitle(),
                        sysMessage.getEsContent().toString());
                // 发送消息成功
                sysMessage.setEsSendStatus(SendMsgStatusEnum.SUCCESS.getCode());
            } catch (Exception e) {
                e.printStackTrace();
                // 发送消息出现异常
                sysMessage.setEsSendStatus(SendMsgStatusEnum.FAIL.getCode());
            }
            sysMessage.setEsSendNum(++sendNum);
            // 发送结果回写到数据库
            sysMessageService.updateById(sysMessage);
        }
    }
}

其他实现类

短信接口配置

阿里短信服务文档

可通过支付宝或者淘宝账户注册阿里云账户，同时提供了专门阿里云服务app

获取阿里短信key、签名和模板

获取AccessKey

进入阿里短信服务工作台，点击箭头指向的按钮

进入如下界面，查看创建的key，若没有则需创建所需的key

可使用手机发送验证码创建，保存Ak信息则会生成一个csv文件在本地磁盘上，文件内容对应着key id 和 secret

创建短信签名和短信模板

根据相关资料填写完信息后，等待审核成功

审核成功后，进入签名列表和模板列表查看，需要记住的是签名名称和模板CODE，后续配置会用到

SpringBoot集成阿里短信服务

在pom文件中导入相关依赖

<repositories>
        <repository>
            <id>aliyun</id>
            <name>aliyun Repository</name>
            <url>https://maven.aliyun.com/repository/public</url>
            <snapshots>
                <enabled>false</enabled>
            </snapshots>
        </repository>
</repositories>

或者

<dependency>
    <groupId>com.aliyun</groupId>
    <artifactId>aliyun-java-sdk-core</artifactId>
    <version>4.1.0</version>
    <exclusions>
        <exclusion>
            <artifactId>commons-codec</artifactId>
            <groupId>commons-codec</groupId>
        </exclusion>
        <exclusion>
            <artifactId>activation</artifactId>
            <groupId>javax.activation</groupId>
        </exclusion>
    </exclusions>
</dependency>
<dependency>
    <groupId>com.aliyun</groupId>
    <artifactId>aliyun-java-sdk-dysmsapi</artifactId>
    <version>1.1.0</version>
</dependency>

修改配置文件

jeecg:
  #阿里云oss存储和大鱼短信秘钥配置
  oss:
    accessKey: **********************
    secretKey: **********************
    endpoint: oss-cn-beijing.aliyuncs.com
    bucketName: jeecgdev
    staticDomain: https://static.jeecg.com

获取配置文件短信配置信息

package org.jeecg.config;
import lombok.Data;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Component;
/**
 * 设置静态参数初始化
 */
@Component
@Data
public class StaticConfig {
    @Value("${jeecg.oss.accessKey}")
    private String accessKeyId;
    @Value("${jeecg.oss.secretKey}")
    private String accessKeySecret;
    @Value(value = "${spring.mail.username}")
    private String emailFrom;
    /**
     * 签名密钥串
     */
    @Value(value = "${jeecg.signatureSecret}")
    private String signatureSecret;
    /*@Bean
    public void initStatic() {
       DySmsHelper.setAccessKeyId(accessKeyId);
       DySmsHelper.setAccessKeySecret(accessKeySecret);
       EmailSendMsgHandle.setEmailFrom(emailFrom);
    }*/
}

短信发送接口实现类

package org.jeecg.common.util;
import org.jeecg.config.StaticConfig;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import com.alibaba.fastjson.JSONObject;
import com.aliyuncs.DefaultAcsClient;
import com.aliyuncs.IAcsClient;
import com.aliyuncs.dysmsapi.model.v20170525.SendSmsRequest;
import com.aliyuncs.dysmsapi.model.v20170525.SendSmsResponse;
import com.aliyuncs.exceptions.ClientException;
import com.aliyuncs.profile.DefaultProfile;
import com.aliyuncs.profile.IClientProfile;
/**
 * Created on 17/6/7.
 * 短信API产品的DEMO程序,工程中包含了一个SmsDemo类，直接通过
 * 执行main函数即可体验短信产品API功能(只需要将AK替换成开通了云通信-短信产品功能的AK即可)
 * 工程依赖了2个jar包(存放在工程的libs目录下)
 * 1:aliyun-java-sdk-core.jar
 * 2:aliyun-java-sdk-dysmsapi.jar
 *
 * 备注:Demo工程编码采用UTF-8
 * 国际短信发送请勿参照此DEMO
 */
public class DySmsHelper {
    private final static Logger logger=LoggerFactory.getLogger(DySmsHelper.class);
    //产品名称:云通信短信API产品,开发者无需替换
    static final String product = "Dysmsapi";
    //产品域名,开发者无需替换
    static final String domain = "dysmsapi.aliyuncs.com";
    // TODO 此处需要替换成开发者自己的AK(在阿里云访问控制台寻找)
    static  String accessKeyId;
    static  String accessKeySecret;
    public static void setAccessKeyId(String accessKeyId) {
        DySmsHelper.accessKeyId = accessKeyId;
    }
    public static void setAccessKeySecret(String accessKeySecret) {
        DySmsHelper.accessKeySecret = accessKeySecret;
    }
    public static String getAccessKeyId() {
        return accessKeyId;
    }
    public static String getAccessKeySecret() {
        return accessKeySecret;
    }
    public static boolean sendSms(String phone,JSONObject templateParamJson,DySmsEnum dySmsEnum) throws ClientException {
        //可自助调整超时时间
        System.setProperty("sun.net.client.defaultConnectTimeout", "10000");
        System.setProperty("sun.net.client.defaultReadTimeout", "10000");
        //update-begin-author：taoyan date:20200811 for:配置类数据获取
        StaticConfig staticConfig = SpringContextUtils.getBean(StaticConfig.class);
        setAccessKeyId(staticConfig.getAccessKeyId());
        setAccessKeySecret(staticConfig.getAccessKeySecret());
        //update-end-author：taoyan date:20200811 for:配置类数据获取
        //初始化acsClient,暂不支持region化
        IClientProfile profile = DefaultProfile.getProfile("cn-hangzhou", accessKeyId, accessKeySecret);
        DefaultProfile.addEndpoint("cn-hangzhou", "cn-hangzhou", product, domain);
        IAcsClient acsClient = new DefaultAcsClient(profile);
        //验证json参数
        validateParam(templateParamJson,dySmsEnum);
        //组装请求对象-具体描述见控制台-文档部分内容
        SendSmsRequest request = new SendSmsRequest();
        //必填:待发送手机号
        request.setPhoneNumbers(phone);
        //必填:短信签名-可在短信控制台中找到
        request.setSignName(dySmsEnum.getSignName());
        //必填:短信模板-可在短信控制台中找到
        request.setTemplateCode(dySmsEnum.getTemplateCode());
        //可选:模板中的变量替换JSON串,如模板内容为"亲爱的${name},您的验证码为${code}"时,此处的值为
        request.setTemplateParam(templateParamJson.toJSONString());
        //选填-上行短信扩展码(无特殊需求用户请忽略此字段)
        //request.setSmsUpExtendCode("90997");
        //可选:outId为提供给业务方扩展字段,最终在短信回执消息中将此值带回给调用者
        //request.setOutId("yourOutId");
        boolean result = false;
        //hint 此处可能会抛出异常，注意catch
        SendSmsResponse sendSmsResponse = acsClient.getAcsResponse(request);
        logger.info("短信接口返回的数据----------------");
        logger.info("{Code:" + sendSmsResponse.getCode()+",Message:" + sendSmsResponse.getMessage()+",RequestId:"+ sendSmsResponse.getRequestId()+",BizId:"+sendSmsResponse.getBizId()+"}");
        if ("OK".equals(sendSmsResponse.getCode())) {
            result = true;
        }
        return result;
    }
    private static void validateParam(JSONObject templateParamJson,DySmsEnum dySmsEnum) {
        String keys = dySmsEnum.getKeys();
        String [] keyArr = keys.split(",");
        for(String item :keyArr) {
            if(!templateParamJson.containsKey(item)) {
                throw new RuntimeException("模板缺少参数："+item);
            }
        }
    }
//    public static void main(String[] args) throws ClientException, InterruptedException {
//        JSONObject obj = new JSONObject();
//        obj.put("code", "1234");
//        sendSms("13800138000", obj, DySmsEnum.FORGET_PASSWORD_TEMPLATE_CODE);
//    }
}

调用短信发送接口

JSONObject templateParamJson = new JSONObject();
templateParamJson.put("code","123456");
try {
DySmsHelper.sendSms("17687475079", templateParamJson,DySmsEnum.TEST_CODE);
}catch (Exception e){
e.printStackTrace();
}

接口上送参数说明

注意这里的短信模板是指短信服务上的模板，而不是系统中的消息模板，否则会因找不到模板而报

dySmsEnum短信枚举信息类

package org.jeecg.common.util;
import org.apache.commons.lang3.StringUtils;
public enum DySmsEnum {
    TEST_CODE("SMS_205466924","小伟考勤","code"),
    LOGIN_TEMPLATE_CODE("SMS_175435174","JEECG","code"),
    FORGET_PASSWORD_TEMPLATE_CODE("SMS_175435174","JEECG","code"),
    REGISTER_TEMPLATE_CODE("SMS_175430166","JEECG","code"),
    /**会议通知*/
    MEET_NOTICE_TEMPLATE_CODE("SMS_201480469","H5活动之家","username,title,minute,time"),
    /**我的计划通知*/
    PLAN_NOTICE_TEMPLATE_CODE("SMS_201470515","H5活动之家","username,title,time");
    /**
     * 短信模板编码
     */
    private String templateCode;
    /**
     * 签名
     */
    private String signName;
    /**
     * 短信模板必需的数据名称，多个key以逗号分隔，此处配置作为校验
     */
    private String keys;
    private DySmsEnum(String templateCode,String signName,String keys) {
        this.templateCode = templateCode;
        this.signName = signName;
        this.keys = keys;
    }
    public String getTemplateCode() {
        return templateCode;
    }
    public void setTemplateCode(String templateCode) {
        this.templateCode = templateCode;
    }
    public String getSignName() {
        return signName;
    }
    public void setSignName(String signName) {
        this.signName = signName;
    }
    public String getKeys() {
        return keys;
    }
    public void setKeys(String keys) {
        this.keys = keys;
    }
    public static DySmsEnum toEnum(String templateCode) {
        if(StringUtils.isEmpty(templateCode)){
            return null;
        }
        for(DySmsEnum item : DySmsEnum.values()) {
            if(item.getTemplateCode().equals(templateCode)) {
                return item;
            }
        }
        return null;
    }
}

jeecgboot实现短信推送功能

jeecgboot的推送功能实际是将要推送的消息保存到数据库中，然后通过一个定时任务去定时的将数据库表中未发送或者发送失败次数超过六次以上的消息进行定时发送，保存的消息可通过自定义的模板，讲所需要的参数传进去生成消息，jeecgboot未能实现短信推送的原因就在这里，因为保存的是一整条完整消息，不需要通过传参传入到短信服务给我们的模板中

解决办法

1. 方法一：在短信服务申请一个全局变量的短信模板，后端只需要将短信模板和短信签名写死，即可将数据库的消息进行推送问题，各个短信运营商不支持全局变量的短信模板，而且即便添加了文字 如：系统消息：{message}这样的模板也是行不通的，客服给的说法是{message}这个变量的意义太广泛
2. 方法二：可通过调用某些云服务平台提供的短信接口来实现短信发送，只需要我们将发送的内容传过去即可发送短信，目前这种方法是满足jeecgboot的短信推送功能的

   邮箱接口配置

   获取邮箱服务密钥（以QQ邮箱服务为例）

进入QQ邮箱

开启相关服务获取密钥，或通过点击生成授权码获取密钥

SpringBoot集成邮箱服务

在pom文件中引入邮箱服务依赖

<resources>
    <resource>
        <directory>src/main/resources</directory>
        <filtering>true</filtering>
    </resource>
</resources>

或者

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-mail</artifactId>
</dependency>

修改配置文件

spring:
    mail:
        host: smtp.qq.com           #邮箱服务类型，我这选的是QQ邮箱服务  
        username: ***************** #邮箱地址
        password: ***************** #邮箱密钥
        properties:
          mail:
            smtp:
              auth: true
              starttls:
                enable: true
                required: true

获取配置文件邮箱配置信息

package org.jeecg.config;
import lombok.Data;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Component;
/**
 * 设置静态参数初始化
 */
@Component
@Data
public class StaticConfig {
    @Value("${jeecg.oss.accessKey}")
    private String accessKeyId;
    @Value("${jeecg.oss.secretKey}")
    private String accessKeySecret;
    @Value(value = "${spring.mail.username}")
    private String emailFrom;
    /**
     * 签名密钥串
     */
    @Value(value = "${jeecg.signatureSecret}")
    private String signatureSecret;
    /*@Bean
    public void initStatic() {
       DySmsHelper.setAccessKeyId(accessKeyId);
       DySmsHelper.setAccessKeySecret(accessKeySecret);
       EmailSendMsgHandle.setEmailFrom(emailFrom);
    }*/
}

这里需要注意的是，获取密钥是通过mailSender这个bean类去获取的

    protected <T> T doGetBean(String name, @Nullable Class<T> requiredType, @Nullable Object[] args, boolean typeCheckOnly) throws BeansException {
        String beanName = this.transformedBeanName(name);
        Object sharedInstance = this.getSingleton(beanName);
        Object bean;
        if (sharedInstance != null && args == null) {
            if (this.logger.isTraceEnabled()) {
                if (this.isSingletonCurrentlyInCreation(beanName)) {
                    this.logger.trace("Returning eagerly cached instance of singleton bean '" + beanName + "' that is not fully initialized yet - a consequence of a circular reference");
                } else {
                    this.logger.trace("Returning cached instance of singleton bean '" + beanName + "'");
                }
            }
            bean = this.getObjectForBeanInstance(sharedInstance, name, beanName, (RootBeanDefinition)null);
        } else {
            if (this.isPrototypeCurrentlyInCreation(beanName)) {
                throw new BeanCurrentlyInCreationException(beanName);
            }
            BeanFactory parentBeanFactory = this.getParentBeanFactory();
            if (parentBeanFactory != null && !this.containsBeanDefinition(beanName)) {
                String nameToLookup = this.originalBeanName(name);
                if (parentBeanFactory instanceof AbstractBeanFactory) {
                    return ((AbstractBeanFactory)parentBeanFactory).doGetBean(nameToLookup, requiredType, args, typeCheckOnly);
                }
                if (args != null) {
                    return parentBeanFactory.getBean(nameToLookup, args);
                }
                if (requiredType != null) {
                    return parentBeanFactory.getBean(nameToLookup, requiredType);
                }
                return parentBeanFactory.getBean(nameToLookup);
            }
            if (!typeCheckOnly) {
                this.markBeanAsCreated(beanName);
            }
            try {
                RootBeanDefinition mbd = this.getMergedLocalBeanDefinition(beanName);
                this.checkMergedBeanDefinition(mbd, beanName, args);
                String[] dependsOn = mbd.getDependsOn();
                String[] var11;
                if (dependsOn != null) {
                    var11 = dependsOn;
                    int var12 = dependsOn.length;
                    for(int var13 = 0; var13 < var12; ++var13) {
                        String dep = var11[var13];
                        if (this.isDependent(beanName, dep)) {
                            throw new BeanCreationException(mbd.getResourceDescription(), beanName, "Circular depends-on relationship between '" + beanName + "' and '" + dep + "'");
                        }
                        this.registerDependentBean(dep, beanName);
                        try {
                            this.getBean(dep);
                        } catch (NoSuchBeanDefinitionException var24) {
                            throw new BeanCreationException(mbd.getResourceDescription(), beanName, "'" + beanName + "' depends on missing bean '" + dep + "'", var24);
                        }
                    }
                }
                if (mbd.isSingleton()) {
                    sharedInstance = this.getSingleton(beanName, () -> {
                        try {
                            return this.createBean(beanName, mbd, args);
                        } catch (BeansException var5) {
                            this.destroySingleton(beanName);
                            throw var5;
                        }
                    });
                    bean = this.getObjectForBeanInstance(sharedInstance, name, beanName, mbd);
                } else if (mbd.isPrototype()) {
                    var11 = null;
                    Object prototypeInstance;
                    try {
                        this.beforePrototypeCreation(beanName);
                        prototypeInstance = this.createBean(beanName, mbd, args);
                    } finally {
                        this.afterPrototypeCreation(beanName);
                    }
                    bean = this.getObjectForBeanInstance(prototypeInstance, name, beanName, mbd);
                } else {
                    String scopeName = mbd.getScope();
                    if (!StringUtils.hasLength(scopeName)) {
                        throw new IllegalStateException("No scope name defined for bean ´" + beanName + "'");
                    }
                    Scope scope = (Scope)this.scopes.get(scopeName);
                    if (scope == null) {
                        throw new IllegalStateException("No Scope registered for scope name '" + scopeName + "'");
                    }
                    try {
                        Object scopedInstance = scope.get(beanName, () -> {
                            this.beforePrototypeCreation(beanName);
                            Object var4;
                            try {
                                var4 = this.createBean(beanName, mbd, args);
                            } finally {
                                this.afterPrototypeCreation(beanName);
                            }
                            return var4;
                        });
                        bean = this.getObjectForBeanInstance(scopedInstance, name, beanName, mbd);
                    } catch (IllegalStateException var23) {
                        throw new BeanCreationException(beanName, "Scope '" + scopeName + "' is not active for the current thread; consider defining a scoped proxy for this bean if you intend to refer to it from a singleton", var23);
                    }
                }
            } catch (BeansException var26) {
                this.cleanupAfterBeanCreationFailure(beanName);
                throw var26;
            }
        }
        if (requiredType != null && !requiredType.isInstance(bean)) {
            try {
                T convertedBean = this.getTypeConverter().convertIfNecessary(bean, requiredType);
                if (convertedBean == null) {
                    throw new BeanNotOfRequiredTypeException(name, requiredType, bean.getClass());
                } else {
                    return convertedBean;
                }
            } catch (TypeMismatchException var25) {
                if (this.logger.isTraceEnabled()) {
                    this.logger.trace("Failed to convert bean '" + name + "' to required type '" + ClassUtils.getQualifiedName(requiredType) + "'", var25);
                }
                throw new BeanNotOfRequiredTypeException(name, requiredType, bean.getClass());
            }
        } else {
            return bean;
        }
    }