使用IDEA创建一个简单的SpringBoot项目(三)

拦截器-模拟登录实现

添加一个入口：

//log演示
@RequestMapping("/log")
@ResponseBody
public String log(String name) {
    logger.info("----this is  a  log4j2 log-----");
    logger.info("----name is "+name+"--------");
    return name;
}

//登录演示
@RequestMapping("/login")
@ResponseBody
public String login(HttpServletRequest request) {
 //模拟成功后返回的session
 request.getSession().setAttribute("name","testUser");
 return "login success";
}

写一个类实现HandlerInterceptor：

public class LoginInterceptor implements HandlerInterceptor {

    private final static Logger logger= LoggerFactory.getLogger(LoginInterceptor.class);

    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) {
        //在 controller 调用之前 访问这个方法
       Object object= request.getSession().getAttribute("name");
        if (object!=null&& object instanceof String){
            String name=(String)object;
           //如果访问了login路由，会获取到session中的值
            if ("testUser".equals(name)){
                logger.info("-----------登录成功---login success-----");
                return true;
            }
        }

        logger.info("-----------登录失败---login fail-----");
        return false;
    }

    @Override
    public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView) {
        //在 controller 调用之后 访问这个方法

    }

    @Override
    public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) {
        //在 渲染完web 页面之后 访问这个方法

    }
}

写一个类继承WebMvcConfigurer，注意添加@Configuration注解

@Configuration
public class WebMvcConfig implements WebMvcConfigurer {
    @Override
    public void addInterceptors(InterceptorRegistry registry) {
        InterceptorRegistration interceptor= registry.addInterceptor(new LoginInterceptor());
        //拦截的方法 可添加多个方法
        //addPathPatterns("/**").addPathPatterns("/log") 或者 addPathPatterns("/**","/log")
        interceptor.addPathPatterns("/log");
        //不拦截的方法
        interceptor.excludePathPatterns("/login");
        //继续添加拦截器
//        registry.addInterceptor(new xxxInterceptor());
    }
}

按上面的配置，如果你不访问login，而直接去访问log，是无法访问的，并且会打印日志———–登录失败—login fail—–

定时器

新建一个类并加上@Component注解，这里给出了两种定时方式，关于cron表达式看下面的图：

@Component
public class UserJob {

    private final static Logger log= LoggerFactory.getLogger(UserJob.class);

//    @Scheduled(fixedRate = 1000) //每一秒种执行一次
    @Scheduled(cron = "0 0 9 * * ?")
    public void birthdayJob(){
        log.info("每一秒种执行一次");
    }
}

定义好该类后，需要在controller中添加注解

@EnableScheduling
public class HelloController {

这样才能启用定时任务

上面的cron表达式的意思是每天上午9点，进程定时任务，更多的cron表达式规则可以看：https://blog.csdn.net/ClementAD/article/details/42042111

spring-boot自定义参数

在application.properties中添加一些自己的配置属性：

##假设这里为阿里芝麻信用的配置
ali.zhima.key=111
ali.zhima.appId=222

新建一个bean，@Value(“${ali.zhima.key}”)中的信息与配置相对应：

@Component
public class AliConfig {
    @Value("${ali.zhima.key}")
    private String key;

    @Value("${ali.zhima.appId}")
    private String appId;

    public String getKey() {
        return key;
    }

    public void setKey(String key) {
        this.key = key;
    }

    public String getAppId() {
        return appId;
    }

    public void setAppId(String appId) {
        this.appId = appId;
    }
}

添加一个访问路由：

//模拟三方参数获取
@Autowired
private AliConfig aliConfig;

@RequestMapping("/customConfig")
@ResponseBody
public String customConfig() {
    return "customConfig-key: "+aliConfig.getKey()+" appid: "+aliConfig.getAppId();
}

访问下http://localhost:8080/customConfig，你就可以得到你要的结果了。

PS：如果你的配置文件中有很多很多配置属性，那么可以采用另外一种方式，前缀：

@Component
@ConfigurationProperties(prefix = "ali.zhima")
public class AliConfig {
    private String key;

    private String appId;

    public String getKey() {
        return key;
    }

    public void setKey(String key) {
        this.key = key;
    }

    public String getAppId() {
        return appId;
    }

    public void setAppId(String appId) {
        this.appId = appId;
    }
}

Spring-boot缓存

添加依赖：

//encache缓存
compile("org.springframework.boot:spring-boot-starter-cache")

新建一个Module，在Module中新建CacheController：

package com.lckiss.controller;

@Controller
@EnableCaching//开启缓存的开关
public class CacheController {

    @RequestMapping("/")
    @ResponseBody
    public String index() {
        return "Greetings from Spring Boot!";
    }


    //------http://localhost:8080/user----使用缓存
    @Autowired
    private UserMapper userMapper;

    @RequestMapping("/user")
    @ResponseBody
    public String user(int id) {
       User user= userMapper.selectUserById(id);
        return user.toString();
    }

    //-----http://localhost:8080/clearCache-----删除缓存
    @Autowired
    private CacheManager cacheManager;

    @RequestMapping("/clearCache")
    @ResponseBody
    public String clearCache(int id) {
        //清除缓存
        cacheManager.getCache("baseCache").clear();
        //重新查询
        User user= userMapper.selectUserById(id);
        return user.toString();
    }
}

dao：

package com.lckiss.mapper;

@CacheConfig(cacheNames = "baseCache")
@Mapper
public interface UserMapper {

    @Cacheable
    @Select("select * from user where id=#{id}")
    User selectUserById(@Param("id") Integer id);
}

入口：

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

}

bean：

package com.lckiss.model;

public class User {
    private Integer id;
    private String name;

    public Integer getId() {
        return id;
    }

    public void setId(Integer id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    @Override
    public String toString() {
        return "User{" +
                "id=" + id +
                ", name='" + name + '\'' +
                '}';
    }
}

在resources目录下新建encache.xml

<?xml version="1.0" encoding="UTF-8"?>
<ehcache xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:noNamespaceSchemaLocation="http://ehcache.org/ehcache.xsd"
         updateCheck="false">
    <defaultCache
            eternal="false"
            maxElementsInMemory="5000"
            overflowToDisk="false"
            diskPersistent="false"
            timeToIdleSeconds="120"
            timeToLiveSeconds="120"
            memoryStoreEvictionPolicy="LRU" />

    <!-- 这里的 baseCache 缓存空间是为代码准备的 -->
    <cache
            name="baseCache"
            maxElementsInMemory="10000"
            maxElementsOnDisk="10000"
             />
</ehcache>

解释如下：

diskStore：为缓存路径，ehcache分为内存和磁盘两级，此属性定义磁盘的缓存位置。
defaultCache：默认缓存策略，当ehcache找不到定义的缓存时，则使用这个缓存策略。只能定义一个。
name:缓存名称。
maxElementsInMemory:缓存最大数目
maxElementsOnDisk：硬盘最大缓存个数。
eternal:对象是否永久有效，一但设置了，timeout将不起作用。
overflowToDisk:是否保存到磁盘，当系统当机时
timeToIdleSeconds:设置对象在失效前的允许闲置时间（单位：秒）。仅当eternal=false对象不是永久有效时使用，可选属性，默认值是0，也就是可闲置时间无穷大。
timeToLiveSeconds:设置对象在失效前允许存活时间（单位：秒）。最大时间介于创建时间和失效时间之间。仅当eternal=false对象不是永久有效时使用，默认是0.，也就是对象存活时间无穷大。
diskPersistent：是否缓存虚拟机重启期数据 Whether the disk store persists between restarts of the Virtual Machine. The default value is false.diskSpoolBufferSizeMB：这个参数设置DiskStore（磁盘缓存）的缓存区大小。默认是30MB。每个Cache都应该有自己的一个缓冲区。
diskExpiryThreadIntervalSeconds：磁盘失效线程运行时间间隔，默认是120秒。
memoryStoreEvictionPolicy：当达到maxElementsInMemory限制时，Ehcache将会根据指定的策略去清理内存。默认策略是LRU（最近最少使用）。你可以设置为FIFO（先进先出）或是LFU（较少使用）。
clearOnFlush：内存数量最大时是否清除。
memoryStoreEvictionPolicy:可选策略有：LRU（最近最少使用，默认策略）、FIFO（先进先出）、LFU（最少访问次数）。

application.properties数据库连接配置：

#数据源
spring.datasource.url = jdbc:mysql://localhost:3306/SpringBoot?useUnicode=true&characterEncoding=utf-8
spring.datasource.username = root
spring.datasource.password = mysql
spring.datasource.driverClassName = com.mysql.jdbc.Driver

访问后会在规定时间内将数据缓存，如果数据被修改，需要查询真实数据需要先clear。

打包发布

因为是IDEA+GRADLE,所以，看看侧边栏就好了

jar包用java -jar xxx.jar运行，war包放到tomcat下运行。生成的文件可以在项目或者module的build/libs/下找到，默认命名为项目名+版本号+SNAPSHOT。

具体war包能否跑起来我未测试，因为有点懒~~~，但是jar包，我为了满足好奇心…

ok，没毛病。

源代码：https://github.com/Anr-C/SpringBoot