SpringBoot集成MyBatis

项目中我集成了AOP 自己封装了一套CRUD 操作和统一异常处理等等，其实都挺简单的想要的朋友请留言在这里我就不贴了

首先需要搭建一个SpringBoot 项目，然后在集成MyBatis 好了步入正题
pom 文件

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <groupId>com.zhangheng</groupId>
    <artifactId>springBootDemo</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <name>SpringBootDemo</name>
    <description>SpringBootDemo</description>
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>1.4.0.RELEASE</version>
    </parent>
    <properties>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
        <java.version>1.8</java.version>
    </properties>
    <dependencies>
        <!-- 引入web项目依赖 -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <!-- jpa 依赖 暂时没用到 -->
        <!-- <dependency> -->
        <!-- <groupId>org.springframework.boot</groupId> -->
        <!-- <artifactId>spring-boot-starter-data-jpa</artifactId> -->
        <!-- </dependency> -->
        <!-- mybatis 依赖 -->
        <dependency>
            <groupId>org.mybatis.spring.boot</groupId>
            <artifactId>mybatis-spring-boot-starter</artifactId>
            <version>1.3.1</version>
        </dependency>
        <!-- mybatis的分页插件 -->
        <dependency>
            <groupId>com.github.pagehelper</groupId>
            <artifactId>pagehelper</artifactId>
            <version>4.1.6</version>
        </dependency>
        <!-- 引入Aop -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-aop</artifactId>
        </dependency>
        <!-- actuator 监控 -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-actuator</artifactId>
        </dependency>
        <!-- 权限控制 -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-security</artifactId>
        </dependency>
        <!-- devtools 开发效率快 热部署 -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-devtools</artifactId>
            <optional>true</optional>
        </dependency>
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <scope>runtime</scope>
        </dependency>
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>druid</artifactId>
            <version>1.1.0</version>
        </dependency>
        <!-- thymeleaf 渲染引擎 -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-thymeleaf</artifactId>
        </dependency>
        <!-- 添加对quartz的支持 -->
        <dependency>
            <groupId>org.quartz-scheduler</groupId>
            <artifactId>quartz</artifactId>
            <version>2.3.0</version>
        </dependency>
        <!-- 发邮件依赖jar -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-mail</artifactId>
        </dependency>
        <dependency>
            <groupId>log4j</groupId>
            <artifactId>log4j</artifactId>
            <version>1.2.17</version>
        </dependency>
    </dependencies>
    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-compiler-plugin</artifactId>
                <configuration>
                    <source>${java.version}</source>
                    <target>${java.version}</target>
                </configuration>
            </plugin>
        </plugins>
    </build>
</project>

上面的配置其实挺简单的基本都有说明如果有不明白的小伙伴请留言下面是我程序的入口：

package com.zhangheng;
import java.util.Properties;
import org.mybatis.spring.annotation.MapperScan;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.EnableAspectJAutoProxy;
import com.github.pagehelper.PageHelper;
/** * 程序启动入口 * * @author zhangh * @date 2018年4月26日上午9:16:27 */
@SpringBootApplication
@EnableAspectJAutoProxy
@MapperScan("com.zhangheng.dao")
public class Application { 
    /** * @author zhangh * @date 2018年4月28日下午5:18:38 * @param args */
    public static void main(String[] args) {
        SpringApplication.run(Application.class, args);
        // 下面的代码可以自定义banner 还可以控制banner的显示方式（log console off）
        // SpringApplication app = new SpringApplication(Application.class);
        // app.setBannerMode(Banner.Mode.OFF);
        // app.run(args);
    }
    @Bean
    public PageHelper pageHelper() {
        PageHelper pageHelper = new PageHelper();
        Properties properties = new Properties();
        properties.setProperty("rowBoundsWithCount", "true");
        properties.setProperty("reasonable", "true");
        properties.setProperty("dialect", "mysql");
        pageHelper.setProperties(properties);
        return pageHelper;
    }
}

下面是我的包结构：
源码结构

接下来讲讲配置文件application.yml：
这是程序的主配置文件入口推荐使用yml格式内容如下：

## 主配置文件 这里存放的是公共的配置信息
# 激活对应的环境的配置文件
spring:
 profiles:
  active: dev
  # 模板引擎为html 位置在templates下
 mvc:
  view:
   prefix: classpath:/templates
   suffix: .html

application-dev.yml 的内容如下：这里我集成了许多Spring 模块如Actuator 监控，security 安全等具体大家去看吧还是那句话不懂的请留言我尽量第一时间回复

# 服务器的端口和contextPath的配置
server:
 port: 10086
 contextPath: /springboot
# Actuator 监控访问端口 默认值跟上面的端口一样
management:
 port: 10087
 context-path: /manage
spring:
 datasource:  # 数据库的配置 用的是阿里的druid连接池
  url: jdbc:mysql://localhost:3306/mytest
  username: root
  password: 111111
  driver-class-name: com.mysql.jdbc.Driver
  type: com.alibaba.druid.pool.DruidDataSource
  initialSize: 5
  minIdle: 5
  maxActive: 20
  maxWait: 60000
  timeBetweenEvictionRunsMillis: 60000
  minEvictableIdleTimeMillis: 300000
  validationQuery: SELECT 1 FROM DUAL
  testWhileIdle: true
  testOnBorrow: false
  testOnReturn: false
  poolPreparedStatements: true
  maxPoolPreparedStatementPerConnectionSize: 20
  filters: stat,wall,log4j
  connectionProperties: druid.stat.mergeSql=true;druid.stat.slowSqlMillis=5000
 devtools: # 热部署机制 需要依赖一个jar
  restart:
   enabled: true
 mail:
  host: smtp.163.com
  username: zhsj201314@163.com
  password: your password
# MyBatis 的配置
mybatis:
 typeAliasesPackage: com.zhangheng.entity
 mapperLocations: classpath:mapper/*.xml # 日志管理 logging: level: com: zhangheng: dao: debug file: logs/spring-boot-logging.log # 权限验证 security: user: name: iflytek2018 password: iflytek2018 # endpoints 介绍 endpoints: shutdown: enabled: false #true 强制下线 info: ##自定义info的id id: myAppInfo info: app: name: springBootDemo version: v0.0.1 author: hengzhang2@iflytek.com author: name: zhangheng email: hengzhang2@iflytek.com age: 18 neck: 永远18岁

说点自己的心得吧
软件行业相信大家第一感受就是钱多如果你觉得你的付出和汇报不成比例难免会不定期的跳槽，那么问题来了怎么更好的面试呢？我个人觉得养成一个良好的编程习惯非常重要。下面我就说说自己的编程习惯：
1 我对代码的认知非常强，一个单词就应该要表达出它的意思。项目中不要随意的命名；
2 多学习java 的多种设计模式，我不推荐大家去死记硬背，要结合项目灵活的使用；
3 要时刻告诉自己一个方法不能超过20行，如果超过了该怎么办；
4 项目中尽量不要出现一些莫名其妙的数字或者字符串，尽量放到一个常量类或者是枚举类中，不过我推荐大家用枚举，因为枚举本身是一个类类就有方法我们还可以操作它们，从而更灵活。
5 要有点责任心，完成自己的任务然后在离职；
6 每天设定一个计划定期去总结，哪怕今天的计划没实现都没关系因为设定一个计划是让自己始终保持一个去学习的动力。

Spring Boot 集成quratz

由于上面我们的pom文件已经加入了对应的maven坐标所以下面我们直接配置quratz，在这里我说一点 spring默认是不管理quratz 中的bean 的，因为它把权力交给了quratz，所以在job中注入spring中的bean是不生效了这也是大家的关系点。有许多中方法可以解决下面我将用一种简单的方法。

quartz.properties 内容其实没啥难度不懂的可以去官网查如果还不懂请留言

## 如果是集群部署 该值设置成true 同时instanceId设置成AUTO 因为要保证集群中的每个实例都是唯一的
#org.quartz.jobStore.isClustered=true
#org.quartz.scheduler.instanceId=AUTO
#org.quartz.scheduler.instanceId=mySchedulerId
org.quartz.scheduler.rmi.export=false
org.quartz.scheduler.rmi.proxy=false
org.quartz.scheduler.wrapJobExecutionInUserTransaction=false
org.quartz.threadPool.class=org.quartz.simpl.SimpleThreadPool
org.quartz.threadPool.threadCount=15
org.quartz.threadPool.threadPriority=5
org.quartz.threadPool.threadsInheritContextClassLoaderOfInitializingThread=false
org.quartz.jobStore.misfireThreshold=5000
# 存储在内存中
#org.quartz.jobStore.class = org.quartz.simpl.RAMJobStore
#定时任务存储在数据库中
org.quartz.jobStore.class=org.quartz.impl.jdbcjobstore.JobStoreTX
org.quartz.jobStore.tablePrefix=QRTZ_
org.quartz.jobStore.dataSource=qzDS
org.quartz.jobStore.driverDelegateClass=org.quartz.impl.jdbcjobstore.StdJDBCDelegate
org.quartz.dataSource.qzDS.driver=com.mysql.jdbc.Driver
org.quartz.dataSource.qzDS.URL=jdbc:mysql://127.0.0.1:3306/quartz?useUnicode=true&characterEncoding=UTF-8
org.quartz.dataSource.qzDS.user=root
org.quartz.dataSource.qzDS.password=111111
org.quartz.dataSource.qzDS.maxConnections=10

下面是我的发邮箱job类
`package com.iflytek.ifi.quartz.myjob;

import org.apache.log4j.Logger;
import org.quartz.Job;
import org.quartz.JobDataMap;
import org.quartz.JobExecutionContext;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
import com.iflytek.ifi.quartz.entity.MyJob;
import com.iflytek.ifi.quartz.entity.User;
import com.iflytek.ifi.quartz.service.impl.UserServiceImpl;
import com.iflytek.ifi.quartz.util.SendMailUtil;

/**
* 发邮件job
*
* @author zhangh
* @date 2018年5月7日下午319
*/
@Component(“sendEmailJob”)
public class SendEmailJob extends MyJob implements Job {
private static Logger logger = Logger.getLogger(SendEmailJob.class);

@Autowired
private SendMailUtil sendMailUtil;
@Autowired
private UserServiceImpl userService;
/**
 * 发邮件的具体内容
 * 
 */
@Override
public void execute(JobExecutionContext context) {
    JobDataMap jobDataMap = context.getJobDetail().getJobDataMap();
    String email = jobDataMap.getString("email");
    String emailType = jobDataMap.getString("emailType");// 1 普通邮件 2模板邮件 默认是普通邮件
    String phone = jobDataMap.getString("phone");
    logger.info(context.getJobDetail().getKey().getGroup()+ phone + context.getJobDetail().getDescription());
    if("2".equals(emailType)){
        try {
            sendMailUtil.sendTemplateMail(email, "模板邮件", jobDataMap);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }else{
        sendMailUtil.sendMail(email, "审核邮件", "恭喜您审核通过");
    }
    userService.add(new User(phone));
}
public SendEmailJob() {}

job 处理类
`package com.iflytek.ifi.quartz.service.impl;

import org.quartz.CronScheduleBuilder;
import org.quartz.CronTrigger;
import org.quartz.Job;
import org.quartz.JobBuilder;
import org.quartz.JobDetail;
import org.quartz.JobKey;
import org.quartz.Scheduler;
import org.quartz.SchedulerException;
import org.quartz.TriggerBuilder;
import org.quartz.TriggerKey;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Service;

import com.iflytek.ifi.quartz.entity.JobEntity;
import com.iflytek.ifi.quartz.service.JobService;

@Service(“jobService”)
public class JobServiceImpl implements JobService {

@Autowired
@Qualifier("Scheduler")
private Scheduler scheduler;
@Value("${myJob.alias.dir}")
private String dir;
@Override
public void addJob(JobEntity jobEntity) throws Exception {
    // 启动调度器
    // scheduler.start();
    // 构建job信息
    JobDetail jobDetail = JobBuilder.newJob(getClass(jobEntity.getJobClassName()).getClass())
                                    .withIdentity(jobEntity.getJobClassName(), jobEntity.getJobGroupName())
                                    .withDescription(jobEntity.getJobDescription())
                                    .storeDurably(jobEntity.getDurabe())
                                    .usingJobData(jobEntity.getJobDataMap())
                                    .build();
    // 表达式调度构建器(即任务执行的时间)
    CronScheduleBuilder scheduleBuilder = CronScheduleBuilder.cronSchedule(jobEntity.getCronExpression());
    // 按新的cronExpression表达式构建一个新的trigger
    CronTrigger trigger = TriggerBuilder.newTrigger()
                                        .withIdentity(jobEntity.getJobClassName(), jobEntity.getJobGroupName())
                                        .withSchedule(scheduleBuilder)
                                        .build();
    scheduler.scheduleJob(jobDetail, trigger);
    if(!jobEntity.getStartWork()){          
        scheduler.pauseJob(JobKey.jobKey(jobEntity.getJobClassName(), jobEntity.getJobGroupName()));
    }
}
private Job getClass(String classname) throws Exception {
    Class<?> class1 = Class.forName(dir+classname.substring(0, 1).toUpperCase()+classname.substring(1));
    return (Job) class1.newInstance();
}
@Override
public void deleteJob(String name,String group) throws SchedulerException {
    scheduler.deleteJob(JobKey.jobKey(name, group));
}
@Override
public void startJob() throws SchedulerException {
    if(!scheduler.isStarted()){
        scheduler.start();
    }       
}
@Override
public void startDelayed(int seconds) throws SchedulerException {
    scheduler.startDelayed(seconds);
}
@Override
public void shutdown() throws SchedulerException {
    if(!scheduler.isShutdown()){
        scheduler.shutdown();
    }
}
@Override
public void shutdown(boolean waitForJobsToComplete) throws SchedulerException {
    scheduler.shutdown(waitForJobsToComplete);
}
@Override
public void pauseJob(String name,String group) throws SchedulerException {
    scheduler.pauseJob(JobKey.jobKey(name, group));
}
@Override
public void pauseTrigger(String name,String group) throws SchedulerException {
    scheduler.pauseTrigger(TriggerKey.triggerKey(name, group));
}
@Override
public void resumeJob(String name,String group) throws SchedulerException {
    scheduler.resumeJob(JobKey.jobKey(name, group));
}
@Override
public void resumeTrigger(String name,String group) throws SchedulerException {
    scheduler.resumeTrigger(TriggerKey.triggerKey(name, group));
}
@Override
public void pauseAll() throws SchedulerException {
    scheduler.pauseAll();
}
@Override
public void resumeAll() throws SchedulerException {
    scheduler.resumeAll();
}

}
`

package com.iflytek.ifi.quartz.service;
import org.quartz.SchedulerException;
import com.iflytek.ifi.quartz.entity.JobEntity;
public interface JobService { 
    /** * 添加任务 * * @author zhangh * @date 2018年5月8日上午8:40:46 * @param jobEntity * @throws Exception */
    public void addJob(JobEntity jobEntity) throws Exception;
    /** * 根据任务名称和分组删除任务 * * @author zhangh * @date 2018年5月8日上午8:40:59 * @param name * @param group * @throws SchedulerException */
    public void deleteJob(String name, String group) throws SchedulerException;
    /** * 开始所有任务 * * @author zhangh * @date 2018年5月8日上午8:41:21 */
    public void startJob() throws SchedulerException;
    /** * 延迟seconds 秒后启动所有任务 * * @author zhangh * @date 2018年5月8日上午8:44:44 * @param seconds * 秒 */
    public void startDelayed(int seconds) throws SchedulerException;
    /** * 关闭所有任务 * * @author zhangh * @date 2018年5月8日上午8:53:39 * @throws SchedulerException */
    public void shutdown() throws SchedulerException;
    /** * 关闭所有任务时 是否等所有的任务执行完毕才关闭 * * @author zhangh * @date 2018年5月8日上午8:54:25 * @param waitForJobsToComplete * @throws SchedulerException */
    public void shutdown(boolean waitForJobsToComplete) throws SchedulerException;
    /** * 暂停任务 * @author zhangh * @date 2018年5月8日下午1:48:24 * @param jobKey * @throws SchedulerException */
    public void pauseJob(String name,String group) throws SchedulerException;
    /** * 暂停触发器 * @author zhangh * @date 2018年5月8日下午1:58:02 * @param triggerKey * @throws SchedulerException */
    public void pauseTrigger(String name,String group) throws SchedulerException;
    /** * 唤醒任务 * @author zhangh * @date 2018年5月8日下午1:58:13 * @param jobKey * @throws SchedulerException */
    public void resumeJob(String name,String group) throws SchedulerException;
    /** * 唤醒触发器 * @author zhangh * @date 2018年5月8日下午1:58:25 * @param triggerKey * @throws SchedulerException */
    public void resumeTrigger(String name,String group) throws SchedulerException;
    /** * 暂停所有任务 * @author zhangh * @date 2018年5月8日下午1:58:35 * @throws SchedulerException */
    public void pauseAll() throws SchedulerException;
    /** * 唤醒所有任务 * @author zhangh * @date 2018年5月8日下午1:58:44 * @throws SchedulerException */
    public void resumeAll() throws SchedulerException;
}
package com.iflytek.ifi.quartz.util;
import java.io.File;
import javax.mail.MessagingException;
import javax.mail.internet.MimeMessage;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.mail.SimpleMailMessage;
import org.springframework.mail.javamail.JavaMailSender;
import org.springframework.mail.javamail.MimeMessageHelper;
import org.springframework.stereotype.Component;
import org.springframework.ui.freemarker.FreeMarkerTemplateUtils;
import org.springframework.web.servlet.view.freemarker.FreeMarkerConfigurer;
import freemarker.template.Template;
/** * 邮件发送工具类 * * @author zhangh * @date 2018年5月10日下午3:00:32 */
@Component
public class SendMailUtil { 
    @Value("${spring.mail.username}")
    private String emailFrom;
    @Autowired
    private FreeMarkerConfigurer freeMarkerConfigurer; // 自动注入
    @Autowired
    private JavaMailSender mailSender;
    /** * 发送普通邮件 * * @author zhangh * @date 2018年5月10日下午2:53:03 * @param sendTo * @param subject * @param content */
    public void sendMail(String sendTo, String subject, String content) {
        SimpleMailMessage message = new SimpleMailMessage();
        message.setFrom(emailFrom);
        message.setTo(sendTo);
        message.setSubject(subject);
        message.setText(content);
        mailSender.send(message);
    }
    /** * 发送html邮件 * * @author zhangh * @date 2018年5月10日下午2:58:53 * @param sendTo * @param subject * @throws MessagingException */
    public void sendHtmlMail(String sendTo, String subject, String htmlContent) throws MessagingException {
        MimeMessage mimeMessage = mailSender.createMimeMessage();
        MimeMessageHelper mimeMessageHelper = new MimeMessageHelper(mimeMessage, true);
        mimeMessageHelper.setFrom(emailFrom);
        mimeMessageHelper.setTo(sendTo);
        mimeMessageHelper.setSubject(subject);
        mimeMessageHelper.setText(htmlContent, true);
        mailSender.send(mimeMessage);
    }
    /** * 发送带附件的邮件 * * @author zhangh * @date 2018年5月10日下午3:09:45 * @param sendTo * @param subject * @param content * @param file * @throws MessagingException */
    public void sendAttachmentMail(String sendTo, String subject, String content, File file) throws MessagingException {
        MimeMessage mimeMessage = mailSender.createMimeMessage();
        MimeMessageHelper mimeMessageHelper = new MimeMessageHelper(mimeMessage, true);
        mimeMessageHelper.setFrom(emailFrom);
        mimeMessageHelper.setTo(sendTo);
        mimeMessageHelper.setSubject(subject);
        mimeMessageHelper.setText(content);
        mimeMessageHelper.addAttachment("image.jpg", file);
        mailSender.send(mimeMessage);
    }
    /** * 发送有静态资源的邮件 * * @author zhangh * @date 2018年5月10日下午3:26:48 * @param sendTo * @param subject * @param content * @param file * @throws MessagingException */
    public void sendInlineMail(String sendTo, String subject, String content, File file) throws MessagingException {
        MimeMessage mimeMessage = mailSender.createMimeMessage();
        MimeMessageHelper mimeMessageHelper = new MimeMessageHelper(mimeMessage, true);
        mimeMessageHelper.setFrom(emailFrom);
        mimeMessageHelper.setTo(sendTo);
        mimeMessageHelper.setSubject(subject);
        mimeMessageHelper.setText("<html><body>带静态资源的邮件内容 图片:<img src='cid:picture' /></body></html>", true);
        mimeMessageHelper.addInline("picture", file);
        mailSender.send(mimeMessage);
    }
    /** * 发送模板邮件 * @author zhangh * @date 2018年5月11日上午10:23:11 * @param sendTo * @param subject * @param model * @throws Exception */
    public void sendTemplateMail(String sendTo, String subject,Object model) throws Exception {
        MimeMessage mimeMessage = mailSender.createMimeMessage();
        MimeMessageHelper mimeMessageHelper = new MimeMessageHelper(mimeMessage, true);
        mimeMessageHelper.setFrom(emailFrom);
        mimeMessageHelper.setTo(sendTo);
        mimeMessageHelper.setSubject(subject);
        Template template = freeMarkerConfigurer.getConfiguration().getTemplate("mail.ftl");
        String html = FreeMarkerTemplateUtils.processTemplateIntoString(template, model);
        mimeMessageHelper.setText(html, true);
        mailSender.send(mimeMessage);
    }
    public SendMailUtil() {
    }
}