Spring Boot高级篇

/**
 * @Cacheable属性介绍
 *
 *  cacheNames/value   指定Cache的名称，CacheManager根据此名称查找对应的Cache
 *
 *  key                如何生成缓存数据的key，可使用SPEL表达式指定，默认使用方法参数的值作为key
 *					   例如：#id、#a0、#p0、#root.args[0]【均是使用参数id作为key】
 *
 *  keyGenerator       key的生成器，可以自己指定规则生成id。key/keyGenerator二选一
 *
 *  condition	       指定条件的情况下才缓存
 *
 *  unless             否定缓存；当unless指定的条件为true，方法的返回值就不会被缓存
 *
 *  sync               是否使用异步模式，默认否
 *
 *  cacheManager/cacheResolver   指定缓存管理器
 */
@Cacheable(cacheNames="employee")
public Employee getEmp(Integer id) {
  return employeeMapper.getEmpById(id);
}

/**
 * beforeInvocation		是否在调用方法之前情况，默认false【如果方法执行出现异常不会删除缓存信息】
 * allEntries			是否删除cacheNames域下的所有缓存信息，默认false
 */
@CacheEvict(cacheNames="employee", key="#id")
public void deleteEmp(Integer id) {
  employeeMapper.deleteEmpById(id);
}

/**
 * 返回值必须是要存入缓存的对象，不可返回void
 */
@CachePut(cacheNames="employee", key="#employee.id")
public Employee updateEmp(Employee employee) {
  employeeMapper.updateEmp(employee);
  return employee;
}

public @interface Caching {
  Cacheable[] cacheable() default {};
  CachePut[] put() default {};
  CacheEvict[] evict() default {};
}

@CacheConfig(cacheNames="employee")
public class EmployeeService {
  //......
}

@Configuration
@ConditionalOnMissingBean(CacheManager.class)
@Conditional(CacheCondition.class)
class SimpleCacheConfiguration {

  //提供了CacheManager
  @Bean
  public ConcurrentMapCacheManager cacheManager() {
    ConcurrentMapCacheManager cacheManager = new ConcurrentMapCacheManager();
    List<String> cacheNames = this.cacheProperties.getCacheNames();
    if (!cacheNames.isEmpty()) {
      cacheManager.setCacheNames(cacheNames);
    }
    return this.customizerInvoker.customize(cacheManager);
  }
}  

public class ConcurrentMapCacheManager implements CacheManager, BeanClassLoaderAware {
  //根据key获得Cache的方法
  public Cache getCache(String name) {
    Cache cache = this.cacheMap.get(name);
    if (cache == null && this.dynamic) {
      synchronized (this.cacheMap) {
        cache = this.cacheMap.get(name);
        if (cache == null) {
          cache = createConcurrentMapCache(name);
          this.cacheMap.put(name, cache);
        }
      }
    }
    return cache;
  }

  //创建Cache
  protected Cache createConcurrentMapCache(String name) {
    SerializationDelegate actualSerialization = (isStoreByValue() ? this.serialization : null);
    return new ConcurrentMapCache(name,
                                  new ConcurrentHashMap<>(256),
                                  isAllowNullValues(), 
                                  actualSerialization);
  }
}

spring:
  redis: 
    cluster:
      max-redirects: 5
      nodes:
      - 192.168.1.158:7000
      - 192.168.1.158:7001
      - 192.168.1.158:7002
      - 192.168.1.158:7003
      - 192.168.1.158:7004
      - 192.168.1.158:7005

@Bean
public RedisTemplate<Object, Object> redisTemplate(RedisConnectionFactory redisConnectionFactory) {
  Jackson2JsonRedisSerializer<Object> jackson2JsonRedisSerializer = new Jackson2JsonRedisSerializer<Object>(Object.class);
  RedisTemplate<Object, Object> template = new RedisTemplate<Object, Object>();
  template.setConnectionFactory(redisConnectionFactory);
  template.setKeySerializer(jackson2JsonRedisSerializer);
  template.setValueSerializer(jackson2JsonRedisSerializer);
  template.setHashKeySerializer(jackson2JsonRedisSerializer);
  template.setHashValueSerializer(jackson2JsonRedisSerializer);
  return template;
}

@Bean
public RedisCacheManager cacheManager(RedisConnectionFactory connectionFactory) {
  RedisCacheConfiguration config = RedisCacheConfiguration.defaultCacheConfig()
    .entryTtl(Duration.ZERO)		//设置缓存过期时间
    .serializeKeysWith(RedisSerializationContext.SerializationPair.fromSerializer(keySerializer()))
    .serializeValuesWith(RedisSerializationContext.SerializationPair.fromSerializer(valueSerializer()))
    .disableCachingNullValues();

  RedisCacheManager redisCacheManager = RedisCacheManager.builder(connectionFactory)
    .cacheDefaults(config)
    .transactionAware()
    .build();

  return redisCacheManager;
}

private RedisSerializer<String> keySerializer() {
  return new StringRedisSerializer();
}


private RedisSerializer<Object> valueSerializer() {
  return new GenericJackson2JsonRedisSerializer();
}

public class EmployeeService {
  public void printCache(){
    Collection<String> cacheNames = cacheManager.getCacheNames();
    System.out.println(cacheNames);
  }
}

//实体类
public class Book {
  @JestId
  private String id;
  private Date postDate;
  private String title;
  private String content;
  private Long authorId;
  //==============Getter/Setter==============
}

//创建数据
@Test
public void testCreate() throws IOException {
  Book book = new Book();
  book.setId("100");
  book.setAuthorId(1001L);
  book.setContent("好看的书");
  book.setPostDate(new Date());
  book.setTitle("jest系列");

  Index.Builder builder = new Index.Builder(book);
  Index index = builder.index("book").type("book_type").build();
  DocumentResult documentResult = jestClient.execute(index);
  System.out.println(documentResult.getJsonString());
}

//查询数据
@Test
public void testQuery() throws IOException {
  XContentBuilder queryBuilder = XContentFactory.jsonBuilder()
    .startObject()
    .startObject("query")
    .startObject("match_all")
    .endObject()
    .endObject()
    .endObject();
  Search search= new Search.Builder( Strings.toString(queryBuilder))
    .addIndex("book").addType("book_type").build();
  SearchResult documentResult = jestClient.execute(search);
  System.out.println(documentResult.getSourceAsString());
}

//创建数据
@Test
public void testCreate() throws IOException {
  Book book = new Book();
  book.setId("100");
  book.setAuthorId(1001L);
  book.setContent("好看的书");
  book.setPostDate(new Date());
  book.setTitle("jest系列");

  IndexQuery indexQuery = new IndexQuery();
  indexQuery.setObject(book);
  indexQuery.setIndexName("book");
  indexQuery.setType("book_type");
  template.index(indexQuery);
}

//查询数据
@Test
public void testQuery() throws IOException {
  NativeSearchQueryBuilder nativeSearchQuery = new NativeSearchQueryBuilder().withQuery(new MatchAllQueryBuilder());
  List<Book> books = template.queryForList(nativeSearchQuery.build(), Book.class);
  System.out.println(books);
}

@Async
public void asyncMethod() throws InterruptedException{
  //do something....
}

/**
 * fixedDelay			一次执行完毕时间点之后多长时间再执行
 * fixedDelayString		与fixedDelay意思相同，只是使用字符串的形式。唯一不同的是支持占位符
 * fixedRate			上一次开始执行时间点之后多长时间再执行
 * fixedRateString		与fixedRate意思相同，只是使用字符串的形式。唯一不同的是支持占位符
 * initialDelay			第一次延迟多长时间后再执行
 * initialDelayString   与initialDelay意思相同，只是使用字符串的形式。唯一不同的是支持占位符
 * zone                 时区，默认取当前计算器时区
 * cron					使用cron表达式进行设置
 */
@Scheduled(cron="0 */1 * * * ?")
public void scheduled() {
    System.out.println("---------------------------");
}