SpringBoot中Shiro缓存使用Redis、Ehcache的方法

SpringBoot 中配置redis作为session 缓存器。 让shiro引用

本文是建立在你是使用这shiro基础之上的补充内容

第一种:Redis缓存,将数据存储到redis 并且开启session存入redis中。

引入pom

  <dependency>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-starter-data-redis</artifactId>
    </dependency>
    <dependency>
      <groupId>org.springframework.session</groupId>
      <artifactId>spring-session-data-redis</artifactId>
   </dependency>

配置redisConfig

@Configuration
@EnableCaching
public class RedisConfig extends CachingConfigurerSupport {
  @Bean
  public KeyGenerator keyGenerator() {
    return new KeyGenerator() {
      @Override
      public Object generate(Object target, Method method, Object... params) {
        StringBuilder sb = new StringBuilder();
        sb.append(target.getClass().getName());
        sb.append(method.getName());
        for (Object obj : params) {
          sb.append(obj.toString());
        }
        return sb.toString();
      }
    };
  }

  @Bean
  //在这里配置缓存reids配置
  public RedisCacheManager cacheManager(RedisConnectionFactory redisConnectionFactory) {
    RedisCacheConfiguration redisCacheConfiguration = RedisCacheConfiguration.defaultCacheConfig()
        .entryTtl(Duration.ofHours(1)); // 设置缓存有效期一小时
    System.out.println("《========【开启redis】 ======== 》 ");
    return RedisCacheManager
        .builder(RedisCacheWriter.nonLockingRedisCacheWriter(redisConnectionFactory))
        .cacheDefaults(redisCacheConfiguration).build();
  }

  @Bean
  public RedisTemplate<String, String> redisTemplate(RedisConnectionFactory factory) {
    StringRedisTemplate template = new StringRedisTemplate(factory);
    Jackson2JsonRedisSerializer jackson2JsonRedisSerializer = new Jackson2JsonRedisSerializer(Object.class);
    ObjectMapper om = new ObjectMapper();
    om.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
    om.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL);
    jackson2JsonRedisSerializer.setObjectMapper(om);
    template.setValueSerializer(jackson2JsonRedisSerializer);
    template.afterPropertiesSet();
    return template;
  }

}

配置自定义缓存管理器,引入redis缓存管理器

定义自己的CacheManager

/**
 * <p> 自定义cacheManage 扩张shiro里面的缓存 使用reids作缓存 </p>
 * <description>
 * 引入自己定义的CacheManager
 * 关于CacheManager的配置文件在spring-redis-cache.xml中
 * </description>
 */
@Component
public class ShiroSpringCacheManager implements CacheManager ,Destroyable{
  /**
   * 将之上的RedisCacheManager的Bean拿出来 注入于此
   */
  @Autowired
  private org.springframework.cache.CacheManager cacheManager;

  public org.springframework.cache.CacheManager getCacheManager() {
    return cacheManager;
  }

  public void setCacheManager(org.springframework.cache.CacheManager cacheManager) {
    this.cacheManager = cacheManager;
  }

  @Override
  public void destroy() throws Exception {
    cacheManager = null;
  }

  @Override
  public <K, V> Cache<K, V> getCache(String name) {
    if (name == null ){
      return null;
    }
    // 新建一个ShiroSpringCache 将Bean放入并实例化
    return new ShiroSpringCache<K,V>(name,getCacheManager());
  }

}

定义自己实现的Shiro的Cache,实现了Shiro包里的Cache

/**
 * <p> 自定义缓存 将数据存入到redis中 </p>
 */
@SuppressWarnings("unchecked")
public class ShiroSpringCache<K,V> implements org.apache.shiro.cache.Cache<K, V>{
  private static final Logger log = LoggerFactory.getLogger(ShiroSpringCache.class);
  private CacheManager cacheManager;
  private Cache cache;

  public ShiroSpringCache(String name, CacheManager cacheManager) {
    if(name==null || cacheManager==null){
      throw new IllegalArgumentException("cacheManager or CacheName cannot be null.");
    }
    this.cacheManager = cacheManager;
    //这里首先是从父类中获取这个cache,如果没有会创建一个redisCache,初始化这个redisCache的时候
    //会设置它的过期时间如果没有配置过这个缓存的,那么默认的缓存时间是为0的,如果配置了,就会把配置的时间赋予给这个RedisCache
    //如果从缓存的过期时间为0,就表示这个RedisCache不存在了,这个redisCache实现了spring中的cache
    this.cache= cacheManager.getCache(name);
  }
  @Override
  public V get(K key) throws CacheException {
    log.info("从缓存中获取key为{}的缓存信息",key);
    if(key == null){
      return null;
    }
    ValueWrapper valueWrapper = cache.get(key);
    if(valueWrapper==null){
      return null;
    }
    return (V) valueWrapper.get();
  }

  @Override
  public V put(K key, V value) throws CacheException {
    log.info("创建新的缓存,信息为:{}={}",key,value);
    cache.put(key, value);
    return get(key);
  }

  @Override
  public V remove(K key) throws CacheException {
    log.info("干掉key为{}的缓存",key);
    V v = get(key);
    cache.evict(key);//干掉这个名字为key的缓存
    return v;
  }

  @Override
  public void clear() throws CacheException {
    log.info("清空所有的缓存");
    cache.clear();
  }

  @Override
  public int size() {
    return cacheManager.getCacheNames().size();
  }

  /**
   * 获取缓存中所的key值
   */
  @Override
  public Set<K> keys() {
    return (Set<K>) cacheManager.getCacheNames();
  }

  /**
   * 获取缓存中所有的values值
   */
  @Override
  public Collection<V> values() {
    return (Collection<V>) cache.get(cacheManager.getCacheNames()).get();
  }

  @Override
  public String toString() {
    return "ShiroSpringCache [cache=" + cache + "]";
  }
}

到此为止,使用redis做缓存,和spring的集成就完成了。

可以使用以下注解将缓存放入redis

 @Cacheable(value = Cache.CONSTANT, key = "'" + CacheKey.DICT_NAME + "'+#name+'_'+#val")

配置spring session管理器

  @Bean
  @ConditionalOnProperty(prefix = "xpro", name = "spring-session-open", havingValue = "true")
  public ServletContainerSessionManager servletContainerSessionManager() {
    return new ServletContainerSessionManager();
  }

新建类 spring session设置session过期时间

/**
 * spring session配置
 *
 * @author xingri
 * @date 2017-07-13 21:05
 */
@EnableRedisHttpSession(maxInactiveIntervalInSeconds = 900) //session过期时间 如果部署多机环境,需要打开注释
@ConditionalOnProperty(prefix = "xpro", name = "spring-session-open", havingValue = "true")
public class SpringSessionConfig {

}

第一种:Ehcache做缓存,可以将数据存储到磁盘中,也可以存到内存中

新建ehcache.xml 文件

<?xml version="1.0" encoding="UTF-8"?>
<ehcache updateCheck="false" dynamicConfig="false">
  <diskStore path="java.io.tmpdir"/>
  <!--授权信息缓存-->
  <cache name="authorizationCache"
      maxEntriesLocalHeap="2000"
      eternal="false"
      timeToIdleSeconds="1800"
      timeToLiveSeconds="1800"
      overflowToDisk="false"
      statistics="true">
  </cache>
<!--身份信息缓存-->
  <cache name="authenticationCache"
      maxEntriesLocalHeap="2000"
      eternal="false"
      timeToIdleSeconds="1800"
      timeToLiveSeconds="1800"
      overflowToDisk="false"
      statistics="true">
  </cache>
<!--session缓存-->
  <cache name="activeSessionCache"
      maxEntriesLocalHeap="2000"
      eternal="false"
      timeToIdleSeconds="1800"
      timeToLiveSeconds="1800"
      overflowToDisk="false"
      statistics="true">
  </cache>

  <!-- 缓存半小时 -->
  <cache name="halfHour"
      maxElementsInMemory="10000"
      maxElementsOnDisk="100000"
      eternal="false"
      timeToIdleSeconds="1800"
      timeToLiveSeconds="1800"
      overflowToDisk="false"
      diskPersistent="false" />

  <!-- 缓存一小时 -->
  <cache name="hour"
      maxElementsInMemory="10000"
      maxElementsOnDisk="100000"
      eternal="false"
      timeToIdleSeconds="3600"
      timeToLiveSeconds="3600"
      overflowToDisk="false"
      diskPersistent="false" />

  <!-- 缓存一天 -->
  <cache name="oneDay"
      maxElementsInMemory="10000"
      maxElementsOnDisk="100000"
      eternal="false"
      timeToIdleSeconds="86400"
      timeToLiveSeconds="86400"
      overflowToDisk="false"
      diskPersistent="false" />

  <!--
    name:缓存名称。
    maxElementsInMemory:缓存最大个数。
    eternal:对象是否永久有效,一但设置了,timeout将不起作用。
    timeToIdleSeconds:设置对象在失效前的允许闲置时间(单位:秒)。仅当eternal=false对象不是永久有效时使用,可选属性,默认值是0,也就是可闲置时间无穷大。
    timeToLiveSeconds:设置对象在失效前允许存活时间(单位:秒)。最大时间介于创建时间和失效时间之间。仅当eternal=false对象不是永久有效时使用,默认是0.,也就是对象存活时间无穷大。
    overflowToDisk:当内存中对象数量达到maxElementsInMemory时,Ehcache将会对象写到磁盘中。
    diskSpoolBufferSizeMB:这个参数设置DiskStore(磁盘缓存)的缓存区大小。默认是30MB。每个Cache都应该有自己的一个缓冲区。
    maxElementsOnDisk:硬盘最大缓存个数。
    diskPersistent:是否缓存虚拟机重启期数据 Whether the disk store persists between restarts of the Virtual Machine. The default value is false.
    diskExpiryThreadIntervalSeconds:磁盘失效线程运行时间间隔,默认是120秒。
    memoryStoreEvictionPolicy:当达到maxElementsInMemory限制时,Ehcache将会根据指定的策略去清理内存。默认策略是LRU(最近最少使用)。你可以设置为FIFO(先进先出)或是LFU(较少使用)。
    clearOnFlush:内存数量最大时是否清除。
  -->
  <defaultCache name="defaultCache"
         maxElementsInMemory="10000"
         eternal="false"
         timeToIdleSeconds="600"
         timeToLiveSeconds="600"
         overflowToDisk="false"
         maxElementsOnDisk="100000"
         diskPersistent="false"
         diskExpiryThreadIntervalSeconds="120"
         memoryStoreEvictionPolicy="LRU"/>

</ehcache>

配置自定义缓存管理器,引入ehcache缓存管理器

/**
 * ehcache配置
 *
 */
@Configuration
@EnableCaching
public class EhCacheConfig {

  /**
   * EhCache的配置
   */
  @Bean
  public EhCacheCacheManager cacheManager(CacheManager cacheManager) {
    MBeanServer mBeanServer = ManagementFactory.getPlatformMBeanServer();
    ManagementService.registerMBeans(cacheManager, mBeanServer, true, true, true, true);
    return new EhCacheCacheManager(cacheManager);
  }

  /**
   * EhCache的配置
   */
  @Bean
  public EhCacheManagerFactoryBean ehcache() {
    System.out.println("《========【开启ehcache】 ======== 》 ");
    EhCacheManagerFactoryBean ehCacheManagerFactoryBean = new EhCacheManagerFactoryBean();
    ehCacheManagerFactoryBean.setConfigLocation(new ClassPathResource("ehcache.xml"));
    return ehCacheManagerFactoryBean;
  }

  @Bean
  public org.apache.shiro.cache.CacheManager getCacheShiroManager(EhCacheManagerFactoryBean ehcache) {
    EhCacheManager ehCacheManager = new EhCacheManager();
    ehCacheManager.setCacheManager(ehcache.getObject());
    return ehCacheManager;
  }
}

最后 最重要的是引入shriro 中

/**
 * shiro权限管理的配置
 *
 */
@Configuration
public class ShiroConfig {

  /**
   * 安全管理器
   */
  @Bean
  public DefaultWebSecurityManager securityManager(CookieRememberMeManager rememberMeManager, CacheManager cacheShiroManager, SessionManager sessionManager) {
    DefaultWebSecurityManager securityManager = new DefaultWebSecurityManager();
    securityManager.setAuthenticator(modularRealmAuthenticator());

    List<Realm> realms=new ArrayList<>();
    securityManager.setRealms(realms);

    securityManager.setCacheManager(cacheShiroManager);

    securityManager.setRememberMeManager(rememberMeManager);
    securityManager.setSessionManager(sessionManager);
    return securityManager;
  }

  /**
   * spring session管理器(多机环境)
   */
  @Bean
  public ServletContainerSessionManager servletContainerSessionManager() {
    return new ServletContainerSessionManager();
  }

  /**
   * session管理器(单机环境) 使用cookie存储缓存。。如果多级请注释
   */
  @Bean
  public DefaultWebSessionManager defaultWebSessionManager(CacheManager cacheShiroManager, XProProperties xProProperties) {
    DefaultWebSessionManager sessionManager = new DefaultWebSessionManager();
    sessionManager.setCacheManager(cacheShiroManager);
    sessionManager.setSessionValidationInterval(xProProperties.getSessionValidationInterval() * 1000);
    sessionManager.setGlobalSessionTimeout(xProProperties.getSessionInvalidateTime() * 1000);
    sessionManager.setDeleteInvalidSessions(true);
    sessionManager.setSessionValidationSchedulerEnabled(true);
    Cookie cookie = new SimpleCookie(ShiroHttpSession.DEFAULT_SESSION_ID_NAME);
    cookie.setName("shiroCookie");
    cookie.setHttpOnly(true);
    sessionManager.setSessionIdCookie(cookie);
    return sessionManager;
  }

  /**
   * 缓存管理器 使用Ehcache实现 如果使用redis则注释下面内容!!!!
   */
  @Bean
  public CacheManager getCacheShiroManager(EhCacheManagerFactoryBean ehcache) {
    EhCacheManager ehCacheManager = new EhCacheManager();
    ehCacheManager.setCacheManager(ehcache.getObject());
    return ehCacheManager;
  }

  /**
   * 项目自定义的Realm
   */
  @Bean
  public ShiroDbRealm shiroDbRealm() {
    return new ShiroDbRealm();
  }

  @Bean
  public ShiroTockenRealm shiroTockenRealm( ) {
    return new ShiroTockenRealm();
  }

  @Bean
  public ShiroJwtRealm shiroJwtRealm( ) {
    return new ShiroJwtRealm();
  }

  /**
   * 系统自带的Realm管理,主要针对多realm
   * */
  @Bean
  public ModularRealmAuthenticator modularRealmAuthenticator(){
    ModularRealmAuthenticator modularRealmAuthenticator=new ModularRealmAuthenticator();
    modularRealmAuthenticator.setAuthenticationStrategy(new AtLeastOneSuccessfulStrategy());
    return modularRealmAuthenticator;
  }
  /**
   * rememberMe管理器, cipherKey生成见{@code Base64Test.java}
   */
  @Bean
  public CookieRememberMeManager rememberMeManager(SimpleCookie rememberMeCookie) {
    CookieRememberMeManager manager = new CookieRememberMeManager();
    manager.setCipherKey(Base64.decode("Z3VucwAAAAAAAAAAAAAAAA=="));
    manager.setCookie(rememberMeCookie);
    return manager;
  }

  /**
   * 记住密码Cookie
   */
  @Bean
  public SimpleCookie rememberMeCookie() {
    SimpleCookie simpleCookie = new SimpleCookie("rememberMe");
    simpleCookie.setHttpOnly(true);
    simpleCookie.setMaxAge(7 * 24 * 60 * 60);//7天
    return simpleCookie;
  }

  /**
   * 在方法中 注入 securityManager,进行代理控制
   */
  @Bean
  public MethodInvokingFactoryBean methodInvokingFactoryBean(DefaultWebSecurityManager securityManager) {
    MethodInvokingFactoryBean bean = new MethodInvokingFactoryBean();
    bean.setStaticMethod("org.apache.shiro.SecurityUtils.setSecurityManager");
    bean.setArguments(new Object[]{securityManager});
    return bean;
  }

  /**
   * 保证实现了Shiro内部lifecycle函数的bean执行
   */
  @Bean
  public LifecycleBeanPostProcessor lifecycleBeanPostProcessor() {
    return new LifecycleBeanPostProcessor();
  }

  /**
   * 启用shrio授权注解拦截方式,AOP式方法级权限检查
   */
  @Bean
  @DependsOn(value = "lifecycleBeanPostProcessor") //依赖其他bean的初始化
  public DefaultAdvisorAutoProxyCreator defaultAdvisorAutoProxyCreator() {
    return new DefaultAdvisorAutoProxyCreator();
  }

  @Bean
  public AuthorizationAttributeSourceAdvisor authorizationAttributeSourceAdvisor(DefaultWebSecurityManager securityManager) {
    AuthorizationAttributeSourceAdvisor authorizationAttributeSourceAdvisor =
        new AuthorizationAttributeSourceAdvisor();
    authorizationAttributeSourceAdvisor.setSecurityManager(securityManager);
    return authorizationAttributeSourceAdvisor;
  }

}

以上就是本文的全部内容,希望对大家的学习有所帮助,也希望大家多多支持我们。

(0)

相关推荐

  • SpringBoot项目中使用redis缓存的方法步骤

    本文介绍了SpringBoot项目中使用redis缓存的方法步骤,分享给大家,具体如下: Spring Data Redis为我们封装了Redis客户端的各种操作,简化使用. - 当Redis当做数据库或者消息队列来操作时,我们一般使用RedisTemplate来操作 - 当Redis作为缓存使用时,我们可以将它作为Spring Cache的实现,直接通过注解使用 1.概述 在应用中有效的利用redis缓存可以很好的提升系统性能,特别是对于查询操作,可以有效的减少数据库压力. 具体的代码参照该

  • 详解Spring Boot使用redis实现数据缓存

    基于spring Boot 1.5.2.RELEASE版本,一方面验证与Redis的集成方法,另外了解使用方法. 集成方法 1.配置依赖 修改pom.xml,增加如下内容. <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-data-redis</artifactId> </dependency> 2.配置R

  • Spring Boot中使用Redis做缓存的方法实例

    前言 本文主要给大家介绍的是关于Spring Boot中使用Redis做缓存的相关内容,这里有两种方式: 使用注解方式(但是小爷不喜欢) 直接<Spring Boot 使用 Redis>中的redisTemplate 下面来看看详细的介绍: 1.创建UserService public interface UserService { public User findById(int id); public User create(User user); public User update(U

  • SpringBoot使用Redis缓存的实现方法

    (1)pom.xml引入jar包,如下: <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-data-redis</artifactId> </dependency> (2)修改项目启动类,增加注解@EnableCaching,开启缓存功能,如下: package springboot; import org

  • 详解SpringBoot集成Redis来实现缓存技术方案

    概述 在我们的日常项目开发过程中缓存是无处不在的,因为它可以极大的提高系统的访问速度,关于缓存的框架也种类繁多,今天主要介绍的是使用现在非常流行的NoSQL数据库(Redis)来实现我们的缓存需求. Redis简介 Redis 是一个开源(BSD许可)的,内存中的数据结构存储系统,它可以用作数据库.缓存和消息中间件,Redis 的优势包括它的速度.支持丰富的数据类型.操作原子性,以及它的通用性. 案例整合 本案例是在之前一篇SpringBoot + Mybatis + RESTful的基础上来集

  • Spring Boot 基于注解的 Redis 缓存使用详解

    看文本之前,请先确定你看过上一篇文章<Spring Boot Redis 集成配置>并保证 Redis 集成后正常可用,因为本文是基于上文继续增加的代码. 一.创建 Caching 配置类 RedisKeys.Java package com.shanhy.example.redis; import java.util.HashMap; import java.util.Map; import javax.annotation.PostConstruct; import org.springf

  • 实例详解Spring Boot实战之Redis缓存登录验证码

    本章简单介绍redis的配置及使用方法,本文示例代码在前面代码的基础上进行修改添加,实现了使用redis进行缓存验证码,以及校验验证码的过程. 1.添加依赖库(添加redis库,以及第三方的验证码库) <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-redis</artifactId> </dependency&

  • spring boot+spring cache实现两级缓存(redis+caffeine)

    spring boot中集成了spring cache,并有多种缓存方式的实现,如:Redis.Caffeine.JCache.EhCache等等.但如果只用一种缓存,要么会有较大的网络消耗(如Redis),要么就是内存占用太大(如Caffeine这种应用内存缓存).在很多场景下,可以结合起来实现一.二级缓存的方式,能够很大程度提高应用的处理效率. 内容说明: 缓存.两级缓存 spring cache:主要包含spring cache定义的接口方法说明和注解中的属性说明 spring boot

  • SpringBoot中Shiro缓存使用Redis、Ehcache的方法

    SpringBoot 中配置redis作为session 缓存器. 让shiro引用 本文是建立在你是使用这shiro基础之上的补充内容 第一种:Redis缓存,将数据存储到redis 并且开启session存入redis中. 引入pom <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-data-redis</artifac

  • Springboot中使用缓存的示例代码

    在开发中,如果相同的查询条件去频繁查询数据库, 是不是会给数据库带来很大的压力呢? 因此,我们需要对查询出来的数据进行缓存,这样客户端只需要从数据库查询一次数据,然后会放入缓存中,以后再次查询时可以从缓存中读取. Spring3开始提供了强大的基于注解的缓存支持,可以通过注解配置方式低侵入的给原有Spring应用增加缓存功能,提高数据访问性能.  具体在Springboot中使用缓存如下: 1.在pom.xml中引入cache依赖,添加如下内容: <dependency> <groupI

  • SpringBoot中默认缓存实现方案的示例代码

    在上一节中,我带大家学习了在Spring Boot中对缓存的实现方案,尤其是结合Spring Cache的注解的实现方案,接下来在本章节中,我带大家通过代码来实现. 一. Spring Boot实现默认缓存 1. 创建web项目 我们按照之前的经验,创建一个web程序,并将之改造成Spring Boot项目,具体过程略. 2. 添加依赖包 <dependency> <groupId>org.springframework.boot</groupId> <artif

  • 详解springboot中各个版本的redis配置问题

    今天在springboot中使用数据库,springboot版本为2.0.2.RELEASE,通过pom引入jar包,配置文件application.properties中的redis配置文件报错,提示例如deprecated configuration property 'spring.redis.pool.max-active',猜想应该是版本不对,发现springboot在1.4前后集成redis发生了一些变化.下面截图看下. 一.不同版本RedisProperties的区别 这是spri

  • SpringBoot中shiro过滤器的重写与配置详解

    目录 问题 解决方案 实现代码 1.重写shiro 登录 过滤器 2.重写role权限 过滤器 3.配置过滤器 问题 遇到问题:在前后端分离跨域访问的项目中shiro进行权限拦截失效 (即使有正确权限的访问也会被拦截) 时造成302重定向错误等问题报错:Response for preflight is invalid (redirect) 1.302原因:使用ajax访问后端项目时无法识别重定向操作 2.shiro拦截失效原因:跨域访问时有一种带预检访问的跨域,即访问时先发出一条methods

  • springboot中shiro使用自定义注解屏蔽接口鉴权实现

    目录 传统做法 使用自定义注解屏蔽接口鉴权 拓展内容:关于spring中的派生注解 传统做法 spring boot整合shiro后,如果某些接口需要屏蔽鉴权的话(比如登录)接口,我们一般会这么做: @Bean(name = "shiroFilter") public ShiroFilterFactoryBean shiroFilterFactoryBean(org.apache.shiro.mgt.SecurityManager securityManager) { ShiroFil

  • 详解SpringBoot中自定义和配置拦截器的方法

    目录 1.SpringBoot版本 2.什么是拦截器 3.工作原理 4.拦截器的工作流程 4.1正常流程 4.2中断流程 5.应用场景 6.如何自定义一个拦截器 7.如何使其在Spring Boot中生效 8.实际使用 8.1场景模拟 8.2思路 8.3实现过程 8.4效果体验 9.总结 1.SpringBoot版本 本文基于的Spring Boot的版本是2.6.7 . 2.什么是拦截器 Spring MVC中的拦截器(Interceptor)类似于ServLet中的过滤器(Filter),它

  • SpringBoot中的异常处理与参数校验的方法实现

    兄弟们好,这次来跟老铁交流两个问题,异常和参数校验,在说参数校验之前我们先来说异常处理吧,因为后面参数的校验会牵扯到异常处理这块的内容. 异常处理 说到异常处理,我不知道大家有没有写过或者遇到过如下的写法. public void saveUser() { try { // 所有的业务内容,目测几百行 }catch (Exception e) { e.printStackTrace(); } } 如果出现上述的代码,里面包含了大量的业务代码,如果是你写的,赶紧改掉,不是你写的找写的,吐槽赶紧改掉

  • SpringBoot中配置Web静态资源路径的方法

    介绍: 本文章主要针对web项目中的两个问题进行详细解析介绍:1- 页面跳转404,即controller转发无法跳转页面问题:2- 静态资源文件路径问题. 项目工具: Intelij Idea, JDK1.8, SpringBoot 2.1.3 正文: 准备工作:通过Idea创建一个SpringBoot-web项目,此过程不做赘述,创建完成后项目结构如下图: 1- 创建一个controller代码如下: package com.example.webpractice.controller; i

  • 在SpringBoot中,如何使用Netty实现远程调用方法总结

    Netty Netty是一个NIO客户端服务器框架: 它可快速轻松地开发网络应用程序,例如协议服务器和客户端. 它极大地简化和简化了网络编程,例如TCP和UDP套接字服务器. NIO是一种非阻塞IO ,它具有以下的特点 单线程可以连接多个客户端. 选择器可以实现单线程管理多个Channel,新建的通道都要向选择器注册. 一个SelectionKey键表示了一个特定的通道对象和一个特定的选择器对象之间的注册关系. selector进行select()操作可能会产生阻塞,但是可以设置阻塞时间,并且可

随机推荐