SpringBoot总结2

16.springboot集成mybatis-2
17.springBoot实现任务调度
1.定时任务的实现方式
2.方式三spring Task的使用
18.springBoot定时任务升级(动态修改cron参数)
19.springboot+quartz-cronTrigger
20.springBoot+quartz+simpleTrigger
21.springBoot+quartz+simpleTrigger2
22.添加拦截器
23.使用springboot开发小项目

16.springboot集成mybatis-2
16.1 整合mybatis
实现步骤:
1.添加依赖包

<!--mybatis-->
<dependency>
<groupId>org.mybatis.spring.boot</groupId>
 <artifactId>mybatis-spring-boot-starter</artifactId>
<version>1.3.2</version>
</dependency>
<dependency>
  <groupId>mysql</groupId>
<artifactId>mysql-connector-java</artifactId>
<version>5.1.41</version>
</dependency>
<!-- 阿里巴巴的Druid数据库连接池 -->
<dependency>
 <groupId>com.alibaba</groupId>
<artifactId>druid-spring-boot-starter</artifactId>
  <version>1.1.9</version>
</dependency>
<!-- 分页插件 -->
<dependency>
<groupId>com.github.pagehelper</groupId>
<artifactId>pagehelper-spring-boot-starter</artifactId>
 <version>1.2.10</version>
</dependency>
 <dependency>
  	<groupId>com.alibaba</groupId>
  	<artifactId>druid</artifactId>
  	<version>1.1.10</version>
 </dependency>

2.修改配置文件 application.yml
spring:
datasource:
name: dataSource
type: com.alibaba.druid.pool.DruidDataSource
#druid相关配置
druid:
#监控统计拦截的filters
filters: stat
driver-class-name: com.mysql.jdbc.Driver
#基本属性
url: jdbc:mysql://localhost:3306/chaoshi
username: root
password: 123456
#配置初始化大小/最小/最大
initial-size: 1
min-idle: 1
max-active: 20
#获取连接等待超时时间
max-wait: 60000
#间隔多久进行一次检测，检测需要关闭的空闲连接
time-between-eviction-runs-millis: 60000
#一个连接在池中最小生存的时间
min-evictable-idle-time-millis: 300000
mybatis:
mapper-locations: classpath:mapper/*.xml
type-aliases-package: com.qf.bean

3.创建实体类
public class Users {
private int userid;
private String username;
private String password;
private Date birthday;
private String address;
}

4.创建接口
public interface UsersDao{
public List findall();
}

5.创建mappper文件

<?xml version="1.0" encoding="UTF-8" ?>

<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd" >
<mapper namespace="com.qf.dao.UsersDao" >
 <select id="findall" resultType="users">
 select * from  users
</select>
</mapper>

5.创建service

@Service
public class UsersServiceImpl implements UsersService {

@Resource
private UsersDao usersDao;
@Override
public List<Users> getall(int index,int size) {
    PageHelper.startPage(index,size);
    return usersDao.findall();
}
}

6.创建Controller

@Controller //等价于:@Controller+@ResponseBody
public class UserController2 {
@Resource
private UsersService usersService;

@RequestMapping("/getusers")
public String test3(ModelMap map){
    List<Users> users = usersService.getall(1,4);
    for (Users user : users) {
        System.out.println(user.getUsername());
    }
    return "success";
}
}

7.测试（注意要扫dao包）

@SpringBootApplication
@MapperScan("com.qf.dao")
public class Test1  {
public static void main(String[] args) {
    SpringApplication.run(Test1.class,args);
}
}

注意:如果报service层中dao层对象没有赋值，说明mapper没有扫描，这可能是jar包引入的问题，需要重新下载依赖包

17.springBoot实现任务调度
1.定时任务的实现方式
(1)java自带的java.util.Timer类，这个类允许你调取一个java.util.TimerTask任务，使用这种方式可以让你的程序按照某一个频度执行，但不能在指定时间运行，一般用得较少

public class TestTimer {

public static void main(String args[]){
        System.out.println("程序启动");
        new Reminder(3);
}

public static class Reminder{
    Timer timer;
    public Reminder(int sec){
        timer = new Timer();

        //schedule(任务对象，延期时间，间隔时间);
        timer.schedule(new TimerTask(){
            public void run(){
                System.out.println("执行任务:"+new Date());
                //timer.cancel();//取消任务
            }
        }, sec*1000,5000);
    }
}
}

(2)使用Quartz,这是一个功能比较强大的调度器,可以让你的程序在指定时间执行，可以按照某一个频度执行，配置起来稍显复杂，
(3)spring3.0以后自带task,可以将它看成一个轻量级的Quartz,而且使用起来比Quartz简单许多
2.方式三spring Task的使用
实现步骤：
(1)新建maven项目
(2)需要在pom.xml文件中引入spring-boot的依赖包
按照执行的例子添加就可以
jdk版本,springboot-parent,springboot-web
(3)编写启动类
(4)编写定时任务类

 @EnableSheduling的作用主要是注册通过	@import(SchedulingConfiguration.class)注册   ShedulingConfiguration.class
@Configuration
@EnableScheduling
public class MyTask {
@Scheduled(cron="0/10 * * * * *")
public void tast1(){
    System.out.println("我的任务:"+new Date());
}
}    

(5)测试：
public static void main(String[] args) {
SpringApplication.run(Demo2.class,args);
}

注意:spring Task在计算时间的时候，是根据当前服务器的系统时间进行计算的，如果是每10秒执行一次的话，那么它是从系统时间的0,10,20秒进行计算的，如果是每1分钟执行一次的话，那么它是从系统时间的一分钟，2分钟计算的。
     如果这样，那么我会碰到这种情况，就是当我们刚刚启动程序的时候，我们的时间刚好是9：38：55秒，那么就会出现5秒后执行1次输出语句

需要掌握:cron表达式，可以参考之前将Quartz的知识点

18.springBoot定时任务升级(动态修改cron参数)
/** 思路:
* 1.新建一个task class
* 2.在class上添加注解@EnableScheduling
* 3.让class实现接口SchedulingConfigurer
* 4.实现SchedudingConfigurer中的方法
*/

@RestController
@EnableScheduling
public class MyTask2 implements SchedulingConfigurer {

private  String cron="0/10 * * * * ?";

 @Override
public void configureTasks(ScheduledTaskRegistrar scheduledTaskRegistrar) {
  //1.创建Runnable对象
    Runnable runnable=new Runnable() {
        @Override
        public void run() {
            System.out.println("运行任务:"+new Date());
        }
    };
   //2.创建触发器
    Trigger trigger=new Trigger() {
        @Override
        public Date nextExecutionTime(TriggerContext triggerContext) {
            CronTrigger cronTrigger=new CronTrigger(cron);
            return cronTrigger.nextExecutionTime(triggerContext);
        }
    };
     //3.注册任务
    scheduledTaskRegistrar.addTriggerTask(runnable,trigger);
}

@RequestMapping("/changecron")
public String change(String cron){
    this.cron="0/5 * * * * ?";
    return "success";
}  
}

19.springboot+quartz-cronTrigger
1.添加依赖包

<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-context-support</artifactId>
</dependency>
<dependency>
  <groupId>org.quartz-scheduler</groupId>
<artifactId>quartz</artifactId>
 <version>2.2.3</version>
</dependency>

2.创建任务类

@Component
public class JobQuartz {
 //任务内容
public void myjob(){
    System.out.println("开始执行任务，date="+new Date());
}
}

3.创建配置类

@Configuration
public class QuartzConfig {
//1.创建JobDetail,参数是自定义的任务类对象
//注意:这里参数可能会显示红线报错，但是不影响使用
@Bean  
public MethodInvokingJobDetailFactoryBean fb(JobQuartz jobQuartz){
    MethodInvokingJobDetailFactoryBean bean=
            new MethodInvokingJobDetailFactoryBean();
    //设置任务类对象
    bean.setTargetObject(jobQuartz);
    //指定任务类的方法
    bean.setTargetMethod("myjob");
    return bean;
}
//2.创建Trigger
@Bean
public CronTriggerFactoryBean ctfb(MethodInvokingJobDetailFactoryBean jobDetailFactoryBean){
    CronTriggerFactoryBean factoryBean=new CronTriggerFactoryBean();
    factoryBean.setJobDetail(jobDetailFactoryBean.getObject());
    factoryBean.setCronExpression("0/10 * * * * ?");
    return factoryBean;
}
//3.创建调度器
@Bean
public SchedulerFactoryBean ssf(CronTriggerFactoryBean cronTriggerFactoryBean){
    SchedulerFactoryBean factory=new SchedulerFactoryBean();
    factory.setTriggers(cronTriggerFactoryBean.getObject());
    return factory;
}
}

4.添加测试类

@SpringBootApplication
public class Demo2 {
public static void main(String[] args) {
    SpringApplication.run(Demo2.class,args);
}
}

20.springBoot+quartz+simpleTrigger
1.添加依赖(注意版本，不要随意更换我现在使用的版本)

<dependency>
<groupId>org.springframework</groupId>
 <artifactId>spring-context-support</artifactId>
</dependency>
<dependency>
<groupId>org.quartz-scheduler</groupId>
<artifactId>quartz</artifactId>
<version>2.2.3</version>
</dependency>

2.创建调度器工厂类

@Configuration
public class QuartzAdvanced {
//1.创建调度器工厂
@Bean
public SchedulerFactoryBean ssf(){
SchedulerFactoryBean factory=new SchedulerFactoryBean();
return factory;
}
//2.创建调度器
@Bean
public Scheduler sch(){
System.out.println(ssf().getObject());
return ssf().getObject();
}
}

3.创建任务类
public class JobAdvanced implements Job {
@Override
public void execute(JobExecutionContext jobExecutionContext) throws JobExecutionException {
System.out.println(“高级任务,date=”+new Date());
}
}

4.创建触发器和调度器关系

@Service
public class MyTaskAdvanced {
@Autowired
@Qualifier("sch") //这里的sch是步骤2中的方法的名称
private Scheduler scheduler;

@PostConstruct //等同于init-method,指定初始化方法
public void begin(){
    try {
        //1.创建JobDetail
        JobDetail jobDetail=
                JobBuilder.newJob(JobAdvanced.class)
                        .withIdentity("job1","group1").build();
        //2.先创建简单调度器对象,再创建简单触发器 设置5秒重复一次
        SimpleScheduleBuilder builder=
                SimpleScheduleBuilder.simpleSchedule()
                        .withIntervalInSeconds(5).repeatForever();
        Trigger trigger=TriggerBuilder.newTrigger()
                .withIdentity("trigger1","triggergroup1")
                .startNow().withSchedule(builder).build();
        //3.指定调度器
        scheduler.scheduleJob(jobDetail,trigger);
    } catch (Exception e) {
        e.printStackTrace();
    }
}

}

5.测试类:

@SpringBootApplication
public class Demo2 {
public static void main(String[] args) {
    SpringApplication.run(Demo2.class,args);
}
}

21.springBoot+quartz+simpleTrigger2
修改任务类:

public class JobAdvanced implements Job {
@Autowired
private UserService userService;   //这行执行过程中会报空指针异常

@Override
public void execute(JobExecutionContext jobExecutionContext) throws JobExecutionException {
    System.out.println("高级任务,date="+new Date());
    userService.test1();
}
}

原因:quartz中的job是由Quartz框架通过反射动态创建的，这里使用spring的对象时是无法使用的。
Job类，不是spring bean对象
解决方案:使用AutowireCapableBeanFactory进行自动注入job
步骤1:创建一个类

@Component
public class SpringJobBean extends AdaptableJobFactory {

@Autowired
private AutowireCapableBeanFactory capableBeanFactory;

@Override
protected Object createJobInstance(TriggerFiredBundle bundle) throws Exception {
    Object object=super.createJobInstance(bundle);
    capableBeanFactory.autowireBean(object);
    return object;
}
}

步骤2:修改原来的工厂类

@Configuration
public class QuartzAdvanced {
@Autowired
private SpringJobBean jobBean;//新增代码，SpringJobBean是步骤1自定义的类

//1.创建调度器工厂
@Bean
public SchedulerFactoryBean ssf(){
    SchedulerFactoryBean factory=new SchedulerFactoryBean();
    //把job交给spring来管理
    factory.setJobFactory(jobBean);//新增代码
    return factory;
}
}

22.添加拦截器
1.创建类，并实现HandlerInterceptor接口

public class MyInterceptor implements HandlerInterceptor { @Override public boolean preHandle(HttpServletRequest httpServletRequest, HttpServletResponse httpServletResponse, Object o) throws Exception { System.out.println(“之前”); return true; } @Override public void postHandle(HttpServletRequest httpServletRequest, HttpServletResponse httpServletResponse, Object o, ModelAndView modelAndView) throws Exception { System.out.println(“之后”); } @Override public void afterCompletion(HttpServletRequest httpServletRequest, HttpServletResponse httpServletResponse, Object o, Exception e) throws Exception { System.out.println(“最终”); }}
2.创建类，继承WebMvcConfigureAdapter类，覆盖其addInterceptors接口,注册我们自定义的拦截器：
@Configurationpublic class LoginInter extends WebMvcConfigurerAdapter { @Override public void addInterceptors(InterceptorRegistry registry) { //注册自定义拦截器，添加拦截路径和排除拦截路径 registry.addInterceptor(new MyInterceptor()) .addPathPatterns("/") .excludePathPatterns("/login"); }}
3.拦截器栈
@Configurationpublic class LoginInter extends WebMvcConfigurerAdapter { @Override public void addInterceptors(InterceptorRegistry registry) { //注册自定义拦截器，添加拦截路径和排除拦截路径 registry.addInterceptor(new MyInterceptor()) .addPathPatterns("/") .excludePathPatterns("/tologin"); registry.addInterceptor(new MyInterceptor2()) .addPathPatterns("/**") .excludePathPatterns("/login"); }}
23.使用springboot开发小项目