Spring Boot高级篇

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22

/**
 * @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);
}

1
2
3
4
5
6
7
8

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

1
2
3
4
5
6
7
8

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

1
2
3
4
5

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

1
2
3
4

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

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

org.springframework.boot.autoconfigure.cache.GenericCacheConfiguration
org.springframework.boot.autoconfigure.cache.JCacheCacheConfiguration
org.springframework.boot.autoconfigure.cache.EhCacheCacheConfiguration
org.springframework.boot.autoconfigure.cache.HazelcastCacheConfiguration
org.springframework.boot.autoconfigure.cache.InfinispanCacheConfiguration
org.springframework.boot.autoconfigure.cache.CouchbaseCacheConfiguration
org.springframework.boot.autoconfigure.cache.RedisCacheConfiguration
org.springframework.boot.autoconfigure.cache.CaffeineCacheConfiguration
org.springframework.boot.autoconfigure.cache.SimpleCacheConfiguration
org.springframework.boot.autoconfigure.cache.NoOpCacheConfiguratio

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16

@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);
  }
}  

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

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);
  }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

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

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

@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;
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

@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();
}

1
2
3
4
5
6

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

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

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

<!-- 使用jest时导入 -->
<dependency>
  <groupId>io.searchbox</groupId>
  <artifactId>jest</artifactId>
</dependency>

1
2
3
4
5

spring:
  elasticsearch:
    jest:
      uris:
        - "http://192.168.1.155:9300"

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42

//实体类
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());
}

1
2
3
4
5
6

spring:
  data:
    elasticsearch:
      cluster-name: docker-cluster
      #注意端口默认位9300并非http通讯端口
      clusterNodes: 192.168.1.155:9300

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

//创建数据
@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);
}

1
2
3
4

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

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14

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

1
2
3
4

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

1
2
3
4
5

spring:
  mail:
    host: smtp.qq.com
    username: source@qq.com
    password: lvhotbvqbezejfbb #授权码是独立的需要去生成

1
2
3
4
5

<dependency>
  <groupId>org.springframework.boot</groupId>
  <artifactId>spring-boot-devtools</artifactId>
  <optional>true</optional>
</dependency>

1
2
3
4
5

<dependency>
  <groupId>org.springframework.boot</groupId>
  <artifactId>spring-boot-starter-actuator</artifactId>
  <optional>true</optional>
</dependency>

1
2
3
4
5
6

# 启用某个模块，替换模块名shutdown即可
management.endpoint.shutdown.enabled=true

# 将所有模块的默认开启全部置为false，并单独开启某个模块
management.endpoints.enabled-by-default=false
management.endpoint.info.enabled=true

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

management: 
  endpoints: 
    jmx:
      exposure:
        include:
          health,info
     web:
     	 exposure: 
         include: "*"
       exposure:
         exclude: env,beans