idea+spring boot2.0.6+多数据源+quartz+过滤器+拦截器+mq+redis的简单集成

简介

最近突然想做点什么，就先搭建一个spring boot基础框架，把基本组件集成一下先

spring boot 搭建

这是一篇简单集成spring boot相关基础插件的文章

1.新建一个spring boot项目：file->new project->spring Initilizr

2.选择集成的插件，lombok看个人习惯

3.此时spring boot已经集成，不得不说idea还是很方便的，建议将application.propertie改为application.yml，spring boot官方建议使用yml格式的配置文件。
4.pom.xml配置扫描路径

        <resources>
            <!--扫描xml文件-->
            <resource>
                <directory>src/main/java</directory>
                <includes>
                    <include>**/*.xml</include>
                </includes>
                <filtering>true</filtering>
            </resource>
        </resources>

配置多数据源

1.yml文件配置

server:
  port: 9627
  servlet:
    context-path: /demo
spring:
  datasource:
    db1:
      jdbcUrl: jdbc:oracle:thin:@xx.xx.xxx.xx:1521/xxx
      username: username
      password: password
      driver-class-name: oracle.jdbc.OracleDriver
    db2:
      jdbcUrl: jdbc:oracle:thin:@xx.xx.xxx.xx:1521/xxx
      username: username
      password: password
      driver-class-name: oracle.jdbc.OracleDriver

2.进行数据源配置
@MapperScan其中的basePackages就是该数据作用域，在此作用域下mapper都是加载的该数据源
@Primary 必须加，项目有切仅有一个主数据源，必须定义否则报错

DataSourceAConfig （masterDatasource）

@Configuration
@MapperScan(basePackages = "com.example.demo.dao", sqlSessionTemplateRef = "test1SqlSessionTemplate")
public class DataSourceAConfig {

  @Bean(name = "test1DataSource")
  @ConfigurationProperties(prefix = "spring.datasource.titan-master")
  // application.properteis中对应属性的前缀
  @Primary
  public DataSource dataSource1() {
    return DataSourceBuilder.create().build();
  }

  @Bean(name = "test1SqlSessionFactory")
  @Primary
  public SqlSessionFactory testSqlSessionFactory(
      @Qualifier("test1DataSource") DataSource dataSource) throws Exception {
    SqlSessionFactoryBean bean = new SqlSessionFactoryBean();
    bean.setDataSource(dataSource);
    bean.setMapperLocations(
        new PathMatchingResourcePatternResolver().getResources("classpath:mapper/*.xml"));
    return bean.getObject();
  }

  @Bean(name = "test1TransactionManager")
  @Primary
  public DataSourceTransactionManager testTransactionManager(
      @Qualifier("test1DataSource") DataSource dataSource) {
    return new DataSourceTransactionManager(dataSource);
  }

  @Bean(name = "test1SqlSessionTemplate")
  @Primary
  public SqlSessionTemplate testSqlSessionTemplate(
      @Qualifier("test1SqlSessionFactory") SqlSessionFactory sqlSessionFactory) throws Exception {
    return new SqlSessionTemplate(sqlSessionFactory);
  }

}

DataSourceBConfig （slaveDatasource）

@Configuration
@MapperScan(basePackages = "com.example.demo.db2dao", sqlSessionTemplateRef  = "test2SqlSessionTemplate")
public class DataSourceBConfig {


    @Bean(name = "test2DataSource")
    @ConfigurationProperties(prefix = "spring.datasource.db2")
    public DataSource testDataSource() {
        return DataSourceBuilder.create().build();
    }

    @Bean(name = "test2SqlSessionFactory")
    public SqlSessionFactory testSqlSessionFactory(@Qualifier("test2DataSource") DataSource dataSource) throws Exception {
        SqlSessionFactoryBean bean = new SqlSessionFactoryBean();
        bean.setDataSource(dataSource);
        bean.setMapperLocations(new PathMatchingResourcePatternResolver().getResources("classpath:mapper/*.xml"));
        return bean.getObject();
    }

    @Bean(name = "test2TransactionManager")
    public DataSourceTransactionManager testTransactionManager(@Qualifier("test2DataSource") DataSource dataSource) {
        return new DataSourceTransactionManager(dataSource);
    }

    @Bean(name = "test2SqlSessionTemplate")
    public SqlSessionTemplate testSqlSessionTemplate(@Qualifier("test2SqlSessionFactory") SqlSessionFactory sqlSessionFactory) throws Exception {
        return new SqlSessionTemplate(sqlSessionFactory);
    }

}

3.最后写好mapper层，service层 写个测试类就可以跑通了

quartz定时任务配置

spring boot集成定时任务特别简单 直接贴代码 复制即可

pom.xml

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

QuartzConfig

@Configuration
public class QuartzConfig {

  private final int SECOND = 10;

  @Bean
  public JobDetail teatQuartzDetail() {
    return JobBuilder.newJob(TestQuartz.class).withIdentity("testQuartz").storeDurably().build();
  }

  @Bean
  public Trigger testQuartzTrigger() {
    SimpleScheduleBuilder scheduleBuilder = SimpleScheduleBuilder.simpleSchedule()
        .withIntervalInSeconds(SECOND)  //设置时间周期单位秒
        .repeatForever();
    return TriggerBuilder.newTrigger().forJob(teatQuartzDetail())
        .withIdentity("testQuartz")
        .withSchedule(scheduleBuilder)
        .build();
  }
}

TestQuartz(实现具体功能)

public class TestQuartz extends QuartzJobBean {

  /**
   * 定时任务具体功能
   */
  @Override
  protected void executeInternal(JobExecutionContext jobExecutionContext)
      throws JobExecutionException {
    System.out.println("run timed task" + new Date());
  }
}

filter过滤器配置

spring boot集成filter
1.添加 一个自己的filter规则，需要实现javax.servlet.Filter接口，重写doFilter实现过滤

@WebFilter(urlPatterns = { "/*" }, filterName = "MyFilter")
public class MyFilter implements Filter {

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

    @Override
    public void destroy() {

    }

    @Override
    public void doFilter(ServletRequest request, ServletResponse response,
                         FilterChain chain) throws IOException, ServletException {
        HttpServletRequest req = (HttpServletRequest) request;
        HttpServletResponse rep = (HttpServletResponse) response;
        System.out.print("进入filter");
        //TODO 增加自己的过滤逻辑
        chain.doFilter(request, response);
    }

    @Override
    public void init(FilterConfig arg0) throws ServletException {

    }

}

2.在入口文件注册filter

 //注册filter
    @Bean
    public FilterRegistrationBean filterRegistrationBean() {
        FilterRegistrationBean registrationBean = new FilterRegistrationBean();
        MyFilter myFilter = new MyFilter();
        registrationBean.setFilter(myFilter);
        List<String> urlPatterns = new ArrayList<String>();
        urlPatterns.add("/*");
        registrationBean.setUrlPatterns(urlPatterns);
        return registrationBean;
    }

拦截器配置

1.创建拦截器，配置拦截规则

@Component
public class InterceptorConfig implements HandlerInterceptor {

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

  /**
   * 拦截controller
   */
  @Override
  public boolean preHandle(HttpServletRequest httpServletRequest,
      HttpServletResponse httpServletResponse, Object o) throws Exception {

    log.info("开始请求拦截器");
    HttpSession session = httpServletRequest.getSession();
    if (!StringUtils.isEmpty(session.getAttribute("userName"))) {
      //未被拦截，编入逻辑
      return true;
    } else {
      //被拦截、编入逻辑
      return false;
    }

  }

  @Override
  public void postHandle(HttpServletRequest httpServletRequest,
      HttpServletResponse httpServletResponse, Object o, ModelAndView modelAndView)
      throws Exception {
    log.info("视图渲染之前");
  }

  @Override
  public void afterCompletion(HttpServletRequest httpServletRequest,
      HttpServletResponse httpServletResponse, Object o, Exception e) throws Exception {
    log.info("视图渲染之后");
  }
}

2.注册拦截器

@Configuration
public class WebMvcConfig implements WebMvcConfigurer {

    @Autowired
    private InterceptorConfig interceptorConfig;

    @Override
    public void addInterceptors(InterceptorRegistry registry) {
        registry.addInterceptor(interceptorConfig).addPathPatterns("/**").excludePathPatterns("/selectUserByIdForDb2");
    }
}

集成redis

1.添加包

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

2.添加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
    public CacheManager cacheManager(RedisConnectionFactory redisConnectionFactory) {
        RedisCacheConfiguration redisCacheConfiguration = RedisCacheConfiguration.defaultCacheConfig()
                .entryTtl(Duration.ofHours(1)); 
        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;
    }
}

3.添加RedisService

@Service
public class RedisService {
    @Autowired
    private RedisTemplate redisTemplate;
    /**
     * 写入缓存
     * @param key
     * @param value
     * @return
     */
    public boolean set(final String key, Object value) {
        boolean result = false;
        try {
            ValueOperations<Serializable, Object> operations = redisTemplate.opsForValue();
            operations.set(key, value);
            result = true;
        } catch (Exception e) {
            e.printStackTrace();
        }
        return result;
    }
    /**
     * 写入缓存设置时效时间
     * @param key
     * @param value
     * @return
     */
    public boolean set(final String key, Object value, Long expireTime) {
        boolean result = false;
        try {
            ValueOperations<Serializable, Object> operations = redisTemplate.opsForValue();
            operations.set(key, value);
            redisTemplate.expire(key, expireTime, TimeUnit.SECONDS);
            result = true;
        } catch (Exception e) {
            e.printStackTrace();
        }
        return result;
    }
    /**
     * 批量删除对应的value
     * @param keys
     */
    public void remove(final String... keys) {
        for (String key : keys) {
            remove(key);
        }
    }

    /**
     * 批量删除key
     * @param pattern
     */
    public void removePattern(final String pattern) {
        Set<Serializable> keys = redisTemplate.keys(pattern);
        if (keys.size() > 0)
            redisTemplate.delete(keys);
    }
    /**
     * 删除对应的value
     * @param key
     */
    public void remove(final String key) {
        if (exists(key)) {
            redisTemplate.delete(key);
        }
    }
    /**
     * 判断缓存中是否有对应的value
     * @param key
     * @return
     */
    public boolean exists(final String key) {
        return redisTemplate.hasKey(key);
    }
    /**
     * 读取缓存
     * @param key
     * @return
     */
    public Object get(final String key) {
        Object result = null;
        ValueOperations<Serializable, Object> operations = redisTemplate.opsForValue();
        result = operations.get(key);
        return result;
    }
    /**
     * 哈希 添加
     * @param key
     * @param hashKey
     * @param value
     */
    public void hmSet(String key, Object hashKey, Object value){
        HashOperations<String, Object, Object> hash = redisTemplate.opsForHash();
        hash.put(key,hashKey,value);
    }

    /**
     * 哈希获取数据
     * @param key
     * @param hashKey
     * @return
     */
    public Object hmGet(String key, Object hashKey){
        HashOperations<String, Object, Object>  hash = redisTemplate.opsForHash();
        return hash.get(key,hashKey);
    }

    /**
     * 列表添加
     * @param k
     * @param v
     */
    public void lPush(String k,Object v){
        ListOperations<String, Object> list = redisTemplate.opsForList();
        list.rightPush(k,v);
    }

    /**
     * 列表获取
     * @param k
     * @param l
     * @param l1
     * @return
     */
    public List<Object> lRange(String k, long l, long l1){
        ListOperations<String, Object> list = redisTemplate.opsForList();
        return list.range(k,l,l1);
    }

    /**
     * 集合添加
     * @param key
     * @param value
     */
    public void add(String key,Object value){
        SetOperations<String, Object> set = redisTemplate.opsForSet();
        set.add(key,value);
    }

    /**
     * 集合获取
     * @param key
     * @return
     */
    public Set<Object> setMembers(String key){
        SetOperations<String, Object> set = redisTemplate.opsForSet();
        return set.members(key);
    }

    /**
     * 有序集合添加
     * @param key
     * @param value
     * @param scoure
     */
    public void zAdd(String key,Object value,double scoure){
        ZSetOperations<String, Object> zset = redisTemplate.opsForZSet();
        zset.add(key,value,scoure);
    }

    /**
     * 有序集合获取
     * @param key
     * @param scoure
     * @param scoure1
     * @return
     */
    public Set<Object> rangeByScore(String key,double scoure,double scoure1){
        ZSetOperations<String, Object> zset = redisTemplate.opsForZSet();
        return zset.rangeByScore(key, scoure, scoure1);
    }
}

4.application.yml配置redis

spring:
  datasource:
      redis:
      host: localhost
      port: 6379
      jedis:
        pool:
          max-active: 1000
          max-wait: -1
          max-idle: 100
          min-idle: 1

5.最后启动自己的redis 调用RedisService

结语

自己做的一个最简单的架子而已，尽量细化代码了很适合初学者，实现都是最小级。如有什么不对的地方望指正。