流烟默
流烟默

SpringBoot - 缓存入门详解与注解使用实例

【1】JSR107规范

Java Caching定义了5个核心接口，分别是CachingProvider, CacheManager, Cache, Entry 和 Expiry。

CachingProvider：定义了创建、配置、获取、管理和控制多个CacheManager。一个应用可以在运行期访问多个CachingProvider。

CacheManager：定义了创建、配置、获取、管理和控制多个唯一命名的Cache，这些Cache存在于CacheManager的上下文中。一个CacheManager仅被一个CachingProvider所拥有。

Cache：是一个类似Map的数据结构并临时存储以Key为索引的值。一个Cache仅被一个CacheManager所拥有。

Entry：是一个存储在Cache中的key-value对。

Expiry ：每一个存储在Cache中的条目有一个定义的有效期。一旦超过这个时间，条目为过期的状态。一旦过期，条目将不可访问、更新和删除。缓存有效期可以通过ExpiryPolicy设置。

SpringBoot中添加javax.cache依赖：


	javax.cache
	cache-api

项目整合缓存结构示意图如下：

SpringBoot - 缓存入门详解与注解使用实例_第1张图片

实际项目应用中，很少使用JSR107进行整合，通常使用Spring的缓存抽象 ！

【2】Spring缓存抽象

Spring从3.1开始定义了org.springframework.cache.Cache和org.springframework.cache.CacheManager接口来统一不同的缓存技术，
并支持使用JCache（JSR-107）注解简化我们开发。

概念(注解) 描述
Cache 缓存接口，定义缓存操作。实现有：RedisCache、EhCache、ConcurrentMapCache等
CacheManager 缓存管理器，管理各种缓存(Cache)组件
keyGenerator 缓存数据时key生成策略
serializer 缓存数据时value序列化策略
@Cacheable 主要针对方法配置，能够根据方法的请求参数对其结果进行缓存
@CacheEvict 根据方法的请求参数清空缓存
@CachePut 保证方法被调用，又将结果进行缓存
@EnableCaching 开启基于注解的缓存

Cache接口为缓存的组件规范定义，包含缓存的各种操作集合。Cache接口下Spring提供了各种xxxCache的实现；如RedisCache，EhCache , ConcurrentMapCache等；

每次调用需要缓存功能的方法时，Spring会检查检查指定参数的指定的目标方法是否已经被调用过。如果有就直接从缓存中获取方法调用后的结果，如果没有就调用方法并缓存结果后返回给用户，下次调用直接从缓存中获取。

使用Spring缓存抽象时我们需要关注以下两点：

  • 确定方法需要被缓存以及他们的缓存策略
  • 从缓存中读取之前缓存存储的数据

【3】SpringBoot整合Spring缓存示例

① 搭建基本环境

基本环境如下：pom文件引入依赖，配置MyBatis数据源，编写bean、service、controller和Mapper注解类。

依赖示例如下：

	
		org.springframework.boot
			spring-boot-starter-cache
		
	
		org.springframework.boot
		spring-boot-starter-web
	
	
		org.mybatis.spring.boot
		mybatis-spring-boot-starter
		1.3.2
	
	
		mysql
		mysql-connector-java
		runtime

两个bean属性如下：

bean 属性
Employee id lastName gender email dId
Department id departmentName

EmployeeMapper 注解示例(DepartmentMapper类同)：

public interface EmployeeMapper {

    @Select("select * from employee where id=#{id}")
    public Employee getEmpById(Integer id);

    @Insert("insert into employee(lastName,email,gender,d_id) values(#{lastName},#{email},#{gender},#{dId})")
    public void insertEmp(Employee employee);

    @Update("update employee set lastName=#{lastName},email=#{email},gender=#{gender},d_id=#{dId} where id=#{id}")
    public void updateEmp(Employee employee);

    @Delete("delete from employee where id = #{id}")
    public void deleteEmpById(Integer id);
}

EmployeeService示例如下：

@Service
public class EmployeeService {

    @Autowired
    EmployeeMapper employeeMapper;

    public Employee getEmp(Integer id){
        System.out.println("查询"+id+"号员工");
        Employee empById = employeeMapper.getEmpById(id);
        return empById;

    }
}

EmployeeController示例如下：

@RestController
public class EmployeeController {

    @Autowired
    EmployeeService employeeService;


    @GetMapping("/emp/{id}")
    public Employee getEmp(@PathVariable("id") Integer id){
       return employeeService.getEmp(id);
    }
}

数据源配置如下(根据需要自定义配置)：

spring.datasource.url=jdbc:mysql://localhost:3306/test
spring.datasource.username=root
spring.datasource.password=123456
spring.datasource.driver-class-name=com.mysql.jdbc.Driver

# 开启驼峰命名匹配规则
mybatis.configuration.map-underscore-to-camel-case=true
#mybatis.configuration.cache-enabled=true

主程序如下：

@MapperScan(value = "com.web.springboot.mapper")
//不用在每个mapper上添加@Mapper注解
@SpringBootApplication
public class SpringBoot01CacheApplication {

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

② 使用@EnableCaching和@Cacheable测试

@EnableCaching开启基于注解的Spring Cache，@Cacheable作用于方法上，标明该方法结果可被缓存。

源码示例如下：

@MapperScan(value = "com.web.springboot.mapper")
@SpringBootApplication
// 主程序添加@EnableCaching注解
@EnableCaching
public class SpringBoot01CacheApplication {

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

// 具体方法上添加@Cacheable注解
@Cacheable(cacheNames = "emp")
public Employee getEmp(Integer id){
     System.out.println("查询"+id+"号员工");
     Employee empById = employeeMapper.getEmpById(id);
     return empById;
 }

测试，连续两次获取id为1的Employee，控制台输出如下：

这里写图片描述

即，只进行了一次查询，第二次从缓存中直接获取！

注意：此时没有使用第三方缓存组件如Redis、memcached等，本地缓存内容是在内存中！

【4】@EnableCaching注解

Enables Spring’s annotation-driven cache management capability, similar to the support found in Spring’s {@code cache:*} XML namespace.

注解示例如下：

@Configuration
@EnableCaching
public class AppConfig {

     @Bean
     public MyService myService() {
  // configure and return a class having @Cacheable methods
         return new MyService();
     }
//自定义CacheManager
     @Bean
     public CacheManager cacheManager() {
       // configure and return an implementation of Spring's CacheManager SPI
        SimpleCacheManager cacheManager = new SimpleCacheManager();
        cacheManager.setCaches(Arrays.asList(new ConcurrentMapCache("default")));
        return cacheManager;
     }
}

等同于Spring xml配置如下：

源码说明如下：

 * In both of the scenarios above, {@code @EnableCaching} and {@code
 * } are responsible for registering the necessary Spring
 * components that power annotation-driven cache management, such as the
 * {@link org.springframework.cache.interceptor.CacheInterceptor CacheInterceptor} and the
 * proxy- or AspectJ-based advice that weaves the interceptor into the call stack when
 * {@link org.springframework.cache.annotation.Cacheable @Cacheable} methods are invoked.
 *
 * 
If the JSR-107 API and Spring's JCache implementation are present, the necessary
 * components to manage standard cache annotations are also registered. This creates the
 * proxy- or AspectJ-based advice that weaves the interceptor into the call stack when
 * methods annotated with {@code CacheResult}, {@code CachePut}, {@code CacheRemove} or
 * {@code CacheRemoveAll} are invoked.
 *
 * 
A bean of type {@link org.springframework.cache.CacheManager CacheManager}
 * must be registered, as there is no reasonable default that the framework can
 * use as a convention. And whereas the {@code } element assumes
 * a bean named "cacheManager", {@code @EnableCaching} searches for a cache
 * manager bean by type. Therefore, naming of the cache manager bean method is
 * not significant.

【5】@Cacheable注解

源码如下：

 *//标明方法返回结果应该被缓存
 * //每次目标方法被调用前，都会根据给定的方法参数检查是否方法已经被调用(进行了缓存)
 *//默认使用方法参数得到缓存的key,但是你可以在key属性中使用SpELl表达式或者使用自定义的keyGenerator来指定key
 *//如果根据key没有从缓存里拿到值，就调用方法并将返回值进行缓存
@Target({ElementType.METHOD, ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
@Inherited
@Documented
public @interface Cacheable {

	@AliasFor("cacheNames")
	String[] value() default {};

	@AliasFor("value")
	String[] cacheNames() default {};
// value等同于cacheNames，指定方法结果应该被存放的Cache组件名字

	/**
	 * Spring Expression Language (SpEL) expression for computing the key dynamically.
	 * 
Default is {@code ""}, meaning all method parameters are considered as a key,
	 * unless a custom {@link #keyGenerator} has been configured.
	 * // 默认方法的所有参数作为key，除非配置了自定义的keyGenerator
	 * 
The SpEL expression evaluates against a dedicated context that provides the
	 * following meta-data:
	 * 
    
	 * 
  • {@code #root.method}, {@code #root.target}, and {@code #root.caches} for
	 * references to the {@link java.lang.reflect.Method method}, target object, and
	 * affected cache(s) respectively.
    • 
	 * 
  • Shortcuts for the method name ({@code #root.methodName}) and target class
	 * ({@code #root.targetClass}) are also available.
	 * 
  • Method arguments can be accessed by index. For instance the second argument
	 * can be accessed via {@code #root.args[1]}, {@code #p1} or {@code #a1}. Arguments
	 * can also be accessed by name if that information is available.
    • 
	 * 

	 */
	String key() default "";

	/**
	 * The bean name of the custom {@link org.springframework.cache.interceptor.KeyGenerator}
	 * to use.
	 * 
Mutually exclusive with the {@link #key} attribute.
	 * @see CacheConfig#keyGenerator
	 */
	String keyGenerator() default "";

	/**
	 * The bean name of the custom {@link org.springframework.cache.CacheManager} to use to
	 * create a default {@link org.springframework.cache.interceptor.CacheResolver} if none
	 * is set already.
	 * 
Mutually exclusive with the {@link #cacheResolver}  attribute.
	 * @see org.springframework.cache.interceptor.SimpleCacheResolver
	 * @see CacheConfig#cacheManager
	 */
	String cacheManager() default "";

	/**
	 * The bean name of the custom {@link org.springframework.cache.interceptor.CacheResolver}
	 * to use.
	 * @see CacheConfig#cacheResolver
	 */
	String cacheResolver() default "";

	/**
	 * Spring Expression Language (SpEL) expression used for making the method
	 * caching conditional.
	 * 
Default is {@code ""}, meaning the method result is always cached.
	 * 
The SpEL expression evaluates against a dedicated context that provides the
	 * following meta-data:
	 * 
    
	 * 
  • {@code #root.method}, {@code #root.target}, and {@code #root.caches} for
	 * references to the {@link java.lang.reflect.Method method}, target object, and
	 * affected cache(s) respectively.
    • 
	 * 
  • Shortcuts for the method name ({@code #root.methodName}) and target class
	 * ({@code #root.targetClass}) are also available.
	 * 
  • Method arguments can be accessed by index. For instance the second argument
	 * can be accessed via {@code #root.args[1]}, {@code #p1} or {@code #a1}. Arguments
	 * can also be accessed by name if that information is available.
    • 
	 * 

	 */
	String condition() default "";

	/**
	 * Spring Expression Language (SpEL) expression used to veto method caching.
	 * 
Unlike {@link #condition}, this expression is evaluated after the method
	 * has been called and can therefore refer to the {@code result}.
	 * 
Default is {@code ""}, meaning that caching is never vetoed.
	 * 
The SpEL expression evaluates against a dedicated context that provides the
	 * following meta-data:
	 * 
    
	 * 
  • {@code #result} for a reference to the result of the method invocation. For
	 * supported wrappers such as {@code Optional}, {@code #result} refers to the actual
	 * object, not the wrapper
    • 
	 * 
  • {@code #root.method}, {@code #root.target}, and {@code #root.caches} for
	 * references to the {@link java.lang.reflect.Method method}, target object, and
	 * affected cache(s) respectively.
    • 
	 * 
  • Shortcuts for the method name ({@code #root.methodName}) and target class
	 * ({@code #root.targetClass}) are also available.
	 * 
  • Method arguments can be accessed by index. For instance the second argument
	 * can be accessed via {@code #root.args[1]}, {@code #p1} or {@code #a1}. Arguments
	 * can also be accessed by name if that information is available.
    • 
	 * 

	 * @since 3.2
	 */
	String unless() default "";

	/**
	 * Synchronize the invocation of the underlying method if several threads are
	 * attempting to load a value for the same key. The synchronization leads to
	 * a couple of limitations:
	 * 
    
	 * 
  1. {@link #unless()} is not supported
    2. 
	 * 
  2. Only one cache may be specified
    3. 
	 * 
  3. No other cache-related operation can be combined
    4. 
	 * 

	 * This is effectively a hint and the actual cache provider that you are
	 * using may not support it in a synchronized fashion. Check your provider
	 * documentation for more details on the actual semantics.
	 * @since 4.3
	 * @see org.springframework.cache.Cache#get(Object, Callable)
	 */
	boolean sync() default false;

}

CacheManager管理多个Cache组件，对缓存真正的CRUD操作在Cache组件中，每一个Cache组件有自己唯一一个名字。

@Cacheable注解属性简解如下：

cacheNames/value：指定缓存组件的名字,必须指定至少一个。

@Cacheable(value=”mycache”) 
@Cacheable(value={”cache1”,”cache2”}

key：缓存数据使用的key，可以根据该属性进行自定义设置，默认使用方法的参数值。

@Cacheable(value=”testcache”,key=”#userName”)
@Cacheable(value=”testcache”,key=”#root.args[0]”)
@Cacheable(value=”testcache”,key=”#root.methodName+'['+#id+']'”)

keyGenerator : key的生成器，可以自己指定keyGenerator 组件id(自定义keyGenerator )。

cacheManager：指定缓存管理器；cacheResolver指定获取解析器；二者二选一使用。

condition：缓存的条件，可以为空，使用 SpEL 编写，返回 true 或者 false，只有为 true 才进行缓存/清除缓存，在调用方法之前之后都能判断。

@Cacheable(value=”testcache”,condition=”#id>2”)
@Cacheable(value=”testcache”,condition=”#a0>2”)

unless ： 当unless的条件为true时，方法的返回值就不缓存。该表达式只在方法执行之后判断，此时可以拿到返回值result进行判断。条件为true不会缓存，fasle才缓存。

@Cacheable(value=”testcache”,unless=”#result == null”)

sync：是否启用异步模式。默认采用同步方式，在方法执行完将结果放入缓存，可以设置为true，启用异步模式。需要注意的是，异步模式不能与unless同时使用。

【6】Cache SpEL available metametadata

名字 位置 描述 示例
methodName root object 当前被调用的方法名 #root.methodName
method root object 当前被调用的方法 #root.method.name
target root object 当前被调用的目标对象 #root.target
targetClass root object 当前被调用的目标对象类 #root.targetClass
args root object 当前被调用的方法的参数列表 #root.args[0]
caches root object 当前方法调用使用的缓存列表（如@Cacheable(value={“cache1”, “cache2”})），则有两个cache #root.caches[0].name
argument name evaluation context 方法参数的名字. 可以直接 #参数名 ，也可以使用 #p0或#a0 的形式，0代表参数的索引； #a0,#p0
result evaluation context 方法执行后的返回值(仅当方法执行之后的判断有效，如‘unless’，’cache put’的表达式 ’cache evict’的表达式beforeInvocation=false) #result

【7】注册并使用自定义keyGenerator

编写自定义的keyGenerator:

@Configuration
public class MyCacheConfig {

    @Bean
    public KeyGenerator keyGenerator(){
        return new KeyGenerator(){
                @Override
                public Object generate(Object target, Method method, Object... params) {
                    return method.getName()+"["+ Arrays.asList(params).toString()+"]";
                }
        };
    }
}

在方法处指定keyGenerator：

@Cacheable(cacheNames = "emp",keyGenerator = "keyGenerator")
public Employee getEmp(Integer id){
     System.out.println("查询"+id+"号员工");
     Employee empById = employeeMapper.getEmpById(id);
     return empById;
 }

测试如下图：

SpringBoot - 缓存入门详解与注解使用实例_第2张图片

【8】@CachePut注解使用

既调用方法，又更新缓存(先调用方法，然后将方法的返回结果放进缓存)，常见场景如修改了数据库的某个数据，同时更新缓存。

示例如下：

// @CachePut(value = "emp",key="#result.id")
 @CachePut(value = "emp",key="#employee.id")
 public Employee updateEmp(Employee employee){
      System.out.println("调用更新方法！");
      employeeMapper.updateEmp(employee);
      return employee;
  }

注意，@Cacheable中的key是不能使用#result的 ！

【9】@CacheEvict注解使用

默认先执行方法，然后根据参数作为key从缓存中删除数据。如果方法执行过程中抛出了异常，则不会删除缓存中目标数据。

示例如下：

@CacheEvict(value = "emp",key = "#id",allEntries = false)
public void deleEmp(Integer id){
     System.out.println("删除"+id+"号员工");
//   employeeMapper.deleteEmpById(id);
 }

allEntries ：默认false，表示是否全部删除对应缓存组件中的数据。

beforeInvocation：默认false，表示是否在方法执行执行删除缓存。

其他属性见源码如下：

@Target({ElementType.METHOD, ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
@Inherited
@Documented
public @interface CacheEvict {

	/**
	 * Alias for {@link #cacheNames}.
	 */
	@AliasFor("cacheNames")
	String[] value() default {};

	/**
	 * Names of the caches to use for the cache eviction operation.
	 * 
Names may be used to determine the target cache (or caches), matching
	 * the qualifier value or bean name of a specific bean definition.
	 * @since 4.2
	 * @see #value
	 * @see CacheConfig#cacheNames
	 */
	@AliasFor("value")
	String[] cacheNames() default {};

	/**
	 * Spring Expression Language (SpEL) expression for computing the key dynamically.
	 * 
Default is {@code ""}, meaning all method parameters are considered as a key,
	 * unless a custom {@link #keyGenerator} has been set.
	 * 
The SpEL expression evaluates against a dedicated context that provides the
	 * following meta-data:
	 * 
    
	 * 
  • {@code #result} for a reference to the result of the method invocation, which
	 * can only be used if {@link #beforeInvocation()} is {@code false}. For supported
	 * wrappers such as {@code Optional}, {@code #result} refers to the actual object,
	 * not the wrapper
    • 
	 * 
  • {@code #root.method}, {@code #root.target}, and {@code #root.caches} for
	 * references to the {@link java.lang.reflect.Method method}, target object, and
	 * affected cache(s) respectively.
    • 
	 * 
  • Shortcuts for the method name ({@code #root.methodName}) and target class
	 * ({@code #root.targetClass}) are also available.
	 * 
  • Method arguments can be accessed by index. For instance the second argument
	 * can be accessed via {@code #root.args[1]}, {@code #p1} or {@code #a1}. Arguments
	 * can also be accessed by name if that information is available.
    • 
	 * 

	 */
	String key() default "";

	/**
	 * The bean name of the custom {@link org.springframework.cache.interceptor.KeyGenerator}
	 * to use.
	 * 
Mutually exclusive with the {@link #key} attribute.
	 * @see CacheConfig#keyGenerator
	 */
	String keyGenerator() default "";

	/**
	 * The bean name of the custom {@link org.springframework.cache.CacheManager} to use to
	 * create a default {@link org.springframework.cache.interceptor.CacheResolver} if none
	 * is set already.
	 * 
Mutually exclusive with the {@link #cacheResolver} attribute.
	 * @see org.springframework.cache.interceptor.SimpleCacheResolver
	 * @see CacheConfig#cacheManager
	 */
	String cacheManager() default "";

	/**
	 * The bean name of the custom {@link org.springframework.cache.interceptor.CacheResolver}
	 * to use.
	 * @see CacheConfig#cacheResolver
	 */
	String cacheResolver() default "";

	/**
	 * Spring Expression Language (SpEL) expression used for making the cache
	 * eviction operation conditional.
	 * 
Default is {@code ""}, meaning the cache eviction is always performed.
	 * 
The SpEL expression evaluates against a dedicated context that provides the
	 * following meta-data:
	 * 
    
	 * 
  • {@code #root.method}, {@code #root.target}, and {@code #root.caches} for
	 * references to the {@link java.lang.reflect.Method method}, target object, and
	 * affected cache(s) respectively.
    • 
	 * 
  • Shortcuts for the method name ({@code #root.methodName}) and target class
	 * ({@code #root.targetClass}) are also available.
	 * 
  • Method arguments can be accessed by index. For instance the second argument
	 * can be accessed via {@code #root.args[1]}, {@code #p1} or {@code #a1}. Arguments
	 * can also be accessed by name if that information is available.
    • 
	 * 

	 */
	String condition() default "";

	/**
	 * Whether all the entries inside the cache(s) are removed.
	 * 
By default, only the value under the associated key is removed.
	 * 默认只删除对应的key的数据
	 * 
Note that setting this parameter to {@code true} and specifying a
	 * {@link #key} is not allowed.
	 * 需要注意的是#key与该属性设置为true不允许同时存在
	 */
	boolean allEntries() default false;

	/**
	 * Whether the eviction should occur before the method is invoked.
	 * 是否在方法调用前清楚缓存
	 * 
Setting this attribute to {@code true}, causes the eviction to
	 * occur irrespective of the method outcome (i.e., whether it threw an
	 * exception or not).
	 * 如果设置为true，则无论方法是否正常执行，都会在方法执行前清除缓存
	 * 
Defaults to {@code false}, meaning that the cache eviction operation
	 * will occur after the advised method is invoked successfully (i.e.,
	 * only if the invocation did not throw an exception).
	 * 默认在方法正常成功执行后，清除缓存
	 */
	boolean beforeInvocation() default false;

}

【10】@Caching注解

该注解用来构建复杂规则的缓存用例，源码如下：

/**
 * Group annotation for multiple cache annotations (of different or the same type).
 *
 * 
This annotation may be used as a meta-annotation to create custom
 * composed annotations with attribute overrides.
 *
 * @author Costin Leau
 * @author Chris Beams
 * @since 3.1
 */
@Target({ElementType.METHOD, ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
@Inherited
@Documented
public @interface Caching {

	Cacheable[] cacheable() default {};

	CachePut[] put() default {};

	CacheEvict[] evict() default {};

}

实例如下：

@Caching(
            cacheable ={
                    @Cacheable(value ="emp",key = "#lastName")
            },
            put = {
                    @CachePut(value = "emp",key = "#result.id"),
                    @CachePut(value = "emp",key = "#result.email")
            }
    )
public Employee getEmpByLastName(String lastName){
     System.out.println("调用复杂缓存方法");
     return employeeMapper.getEmpByLastName(lastName);
 }

第一次按照lastName进行缓存的同时(cacheable 注解)，@CachePut注解也起作用–分别以id和email为key在缓存中放入数据。

再次进行查询的时候方法仍然会调用，因为@CachePut注解一直起作用！

【11】@CacheConfig注解使用

同一个类中不同方法汇总缓存组件名字一般都相同，可以使用@CacheConfig注解作用在类上配置共同属性值，默认对该类的所有方法起作用。

注解源码如下：

 *@CacheConfig在类级别上提供了共享与缓存相关的公共设置的机制
 当类上面添加了该注解，就意味着提供了一系列默认设置关于该类上定义的缓存操作
@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface CacheConfig {

	/**
	 * Names of the default caches to consider for caching operations defined
	 * in the annotated class.
	 * 
If none is set at the operation level, these are used instead of the default.
	 * 
May be used to determine the target cache (or caches), matching the
	 * qualifier value or the bean names of a specific bean definition.
	 */
	String[] cacheNames() default {};


	 * 使用在该类上面的KeyGenerator类型的bean 实例名字
	 * 
If none is set at the operation level, this one is used instead of the default.
	 * 
The key generator is mutually exclusive with the use of a custom key. When such key is
	 * defined for the operation, the value of this key generator is ignored.
	 */
	String keyGenerator() default "";

	/**
	 * The bean name of the custom {@link org.springframework.cache.CacheManager} to use to
	 * create a default {@link org.springframework.cache.interceptor.CacheResolver} if none
	 * is set already.
	 * 
If no resolver and no cache manager are set at the operation level, and no cache
	 * resolver is set via {@link #cacheResolver}, this one is used instead of the default.
	 * @see org.springframework.cache.interceptor.SimpleCacheResolver
	 */
	String cacheManager() default "";

	/**
	 * The bean name of the custom {@link org.springframework.cache.interceptor.CacheResolver} to use.
	 * 
If no resolver and no cache manager are set at the operation level, this one is used
	 * instead of the default.
	 */
	String cacheResolver() default "";

}

完整示例如下：

@CacheConfig(cacheNames = "emp")
@Service
public class EmployeeService {

    @Autowired
    EmployeeMapper employeeMapper;

    @Cacheable(key = "#id")
    public Employee getEmp(Integer id){
        System.out.println("查询"+id+"号员工");
        Employee empById = employeeMapper.getEmpById(id);
        return empById;
    }

    @CachePut(/*value = "emp",*/key="#employee.id")
    public Employee updateEmp(Employee employee){
        System.out.println("调用更新方法！");
        employeeMapper.updateEmp(employee);
        return employee;
    }

    @CacheEvict(/*value = "emp",*/key = "#id",allEntries = true)
    public void deleEmp(Integer id){
        System.out.println("删除"+id+"号员工");
//        employeeMapper.deleteEmpById(id);
//        int i=10/0;
    }

    @Caching(
            cacheable ={
                    @Cacheable(/*value ="emp",*/key = "#lastName")
            },
            put = {
                    @CachePut(/*value = "emp",*/key = "#result.id"),
                    @CachePut(/*value = "emp",*/key = "#result.email")
            }
    )
    public Employee getEmpByLastName(String lastName){
        System.out.println("调用复杂缓存方法");
        return employeeMapper.getEmpByLastName(lastName);
    }
}

如果方法上指定了该属性值(@CacheConfig中配置的属性)，则使用方法上指定的值：

//如这里put 中将#result.id为key放入emp1缓存组件中
 @Caching(
            cacheable ={
                    @Cacheable(/*value ="emp",*/key = "#lastName")
            },
            put = {
                    @CachePut(value = "emp1",key = "#result.id"),
                    @CachePut(/*value = "emp",*/key = "#result.email")
            }
    )
    public Employee getEmpByLastName(String lastName){
        System.out.println("调用复杂缓存方法");
        return employeeMapper.getEmpByLastName(lastName);
    }

【12】整合第三方缓存-Redis

具体参考博客：https://blog.csdn.net/j080624/article/details/80860715。

项目中引入Redis组件后，就不再使用默认的SimpleCacheConfiguration，而是使用RedisCacheConfiguration。

其源码如下：

@Configuration
@AutoConfigureAfter(RedisAutoConfiguration.class)
@ConditionalOnBean(RedisTemplate.class)
@ConditionalOnMissingBean(CacheManager.class)
@Conditional(CacheCondition.class)
class RedisCacheConfiguration {

	private final CacheProperties cacheProperties;

	private final CacheManagerCustomizers customizerInvoker;

	RedisCacheConfiguration(CacheProperties cacheProperties,
			CacheManagerCustomizers customizerInvoker) {
		this.cacheProperties = cacheProperties;
		this.customizerInvoker = customizerInvoker;
	}
//向容器中注册RedisCacheManager 
	@Bean
	public RedisCacheManager cacheManager(RedisTemplate redisTemplate) {
	//给cacheManager  赋予redisTemplate，用来进行通信
		RedisCacheManager cacheManager = new RedisCacheManager(redisTemplate);
		cacheManager.setUsePrefix(true);
		List cacheNames = this.cacheProperties.getCacheNames();
		if (!cacheNames.isEmpty()) {
			cacheManager.setCacheNames(cacheNames);
		}
		return this.customizerInvoker.customize(cacheManager);
	}

}

【13】自定义RedisCacheManager

默认使用的JDK序列化机制在redis中存的是序列化数据，非直观显示的json数据。如果想要在redis中存放为json数据，可以做如下考虑：自定义RedisCacheManager。

自定义RedisCacheManager源码示例如下：

@Configuration
public class MyRedisConfig {

    @Bean
    public RedisTemplate empRedisTemplate(RedisConnectionFactory connectionFactory){
        RedisTemplate template = new RedisTemplate();
        template.setConnectionFactory(connectionFactory);
        Jackson2JsonRedisSerializer serializer = new Jackson2JsonRedisSerializer(Employee.class);
        template.setDefaultSerializer(serializer);
        return template;
    }
 
    @Bean
    public RedisCacheManager myCacheManager(RedisTemplate empRedisTemplate) {
        RedisCacheManager cacheManager = new RedisCacheManager(empRedisTemplate);
        //默认将CacheName作为key的前缀
        cacheManager.setUsePrefix(true);
        return cacheManager;
    }
}

这样在操作Employee时在redis中存放的即为json数据！但是这种方式有明显局限性，基本不用考虑。

继续往下看！！！

【14】自定义RedisTemplate

替换容器中默认配置的RedisTemplate，源码示例如下：

	//替换默认注册的RedisTemplate，id为redisTemplate
    @Bean
    public RedisTemplate redisTemplate(RedisConnectionFactory connectionFactory){
        RedisTemplate template = new RedisTemplate();
        template.setConnectionFactory(connectionFactory);
        Jackson2JsonRedisSerializer serializer = new Jackson2JsonRedisSerializer(Object.class);
        template.setDefaultSerializer(serializer);
        return template;
    }
 
  
这样，无需替换容器中的RedisCacheManager，即可将任意类型进行JSON化存放Redis中！
 
  
SpringBoot - 缓存入门详解与注解使用实例_第3张图片
 
  
 
  
但是同样有坑，存的时候没有问题，取出来的时候就有问题了，异常如下：
 
  
SpringBoot - 缓存入门详解与注解使用实例_第4张图片
 
  
所以，使用默认的序列化机制，存取对象都没问题，但是在Redis中又不友好，上面的方法显然都不行，继续往下看！！
 
  
 
  
【15】SpringBoot2.0下整合Redis
 
  
pom依赖
 
  


	org.springframework.boot
	spring-boot-starter-data-redis
	
	
		
			io.lettuce
			lettuce-core
		
	



	redis.clients
	jedis





	org.apache.commons
	commons-pool2
	2.5.0
	


 
  
 
  
自定义Redis配置类
 
  
package com.hh.config;

@Configuration
// 必须加，使配置生效
@EnableCaching
public class MyRedisConfig extends CachingConfigurerSupport {
    private static final Logger log = LoggerFactory.getLogger(MyRedisConfig.class);

    @Autowired
    private JedisConnectionFactory jedisConnectionFactory;

    @Bean
    @Override
    public CacheManager cacheManager() {
        // 初始化缓存管理器，在这里我们可以缓存的整体过期时间什么的，我这里默认没有配置
        log.info("初始化 -> [{}]", "CacheManager RedisCacheManager Start");
        RedisCacheManager.RedisCacheManagerBuilder builder = RedisCacheManager
                .RedisCacheManagerBuilder
                .fromConnectionFactory(jedisConnectionFactory);
        return builder.build();
    }

    @Bean
    public RedisTemplate redisTemplate(JedisConnectionFactory jedisConnectionFactory ) {
        //设置序列化
        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);
        // 配置redisTemplate
        RedisTemplate redisTemplate = new RedisTemplate();
        redisTemplate.setConnectionFactory(jedisConnectionFactory);
        RedisSerializer stringSerializer = new StringRedisSerializer();
        redisTemplate.setKeySerializer(stringSerializer); // key序列化
        redisTemplate.setValueSerializer(jackson2JsonRedisSerializer); // value序列化
        redisTemplate.setHashKeySerializer(stringSerializer); // Hash key序列化
        redisTemplate.setHashValueSerializer(jackson2JsonRedisSerializer); // Hash value序列化
        redisTemplate.afterPropertiesSet();
        return redisTemplate;
    }

    @Override
    @Bean
    public CacheErrorHandler errorHandler() {
        // 异常处理，当Redis发生异常时，打印日志，但是程序正常走
        log.info("初始化 -> [{}]", "Redis CacheErrorHandler");
        CacheErrorHandler cacheErrorHandler = new CacheErrorHandler() {
            @Override
            public void handleCacheGetError(RuntimeException e, Cache cache, Object key) {
                log.error("Redis occur handleCacheGetError：key -> [{}]", key, e);
            }

            @Override
            public void handleCachePutError(RuntimeException e, Cache cache, Object key, Object value) {
                log.error("Redis occur handleCachePutError：key -> [{}]；value -> [{}]", key, value, e);
            }

            @Override
            public void handleCacheEvictError(RuntimeException e, Cache cache, Object key)    {
                log.error("Redis occur handleCacheEvictError：key -> [{}]", key, e);
            }

            @Override
            public void handleCacheClearError(RuntimeException e, Cache cache) {
                log.error("Redis occur handleCacheClearError：", e);
            }
        };
        return cacheErrorHandler;
    }
}


 
  
 
  
测试实例如下：
 
  
	@Autowired
	StringRedisTemplate stringRedisTemplate;

	@Autowired
	RedisTemplate redisTemplate;

	@Test
	public void testRedis(){
		// 测试redis
		if(stringRedisTemplate.hasKey("hello")){
			String hello = stringRedisTemplate.opsForValue().get("hello");
			System.out.println("从redis中获取 key-hello--value : "+hello);
			stringRedisTemplate.opsForValue().set("jane","is a boy");

		}
		SysUser sysUser = new SysUser();
		sysUser.setId(1L);
		sysUser.setDataType(1);
		sysUser.setIdentity("4125XXXX");
		redisTemplate.opsForValue().set("sysUser",sysUser);
		SysUser sysUser2 = (SysUser) redisTemplate.opsForValue().get("sysUser");
		System.out.println(sysUser2);
	}

 
  
测试结果如下图：
 这里写图片描述
 
  
如果使用Redis作为Cache实现，那么数据将会自动被缓存到Redis中。@Cacheable加了该注解的方法将会首先尝试从Redis中获取数据，如果没有数据则执行具体方法，将方法结果缓存到Redis中。再次查询时，将直接从Redis中获取，不会再执行具体方法。
 
  
需要注意的是，该种方式不用显示手动使用RedisTemplate进行存取！因为数据是存储在Redis中的，即使应用重启，再次查询同样直接从Redis中获取，不再执行具体方法
 
  
 @Cacheable(cacheNames = "emp")
 public Employee getEmp(Integer id){
      System.out.println("查询"+id+"号员工");
      Employee empById = employeeMapper.getEmpById(id);
      return empById;
  }

 
  
参考博文：
 聊聊分布式应用中的缓存方案
 
  

                            
                        
                    
                    
                    

                    
                    
                    

                
                

                    
                

            
        
    
    

        
你可能感兴趣的:(SpringBoot)

        

            

                
    
                    
  • Java连接Zookeeper，创建监听通知机制
                        永旗狍子
SpringLinuxzookeeperjava
                        
    目录一.Java连接Zookeeper1.创建Springboot工程，导入依赖1.1排除log4j和桥接包2.配置application.yml3.编写连接Zookeeper的工具类4.监听通知机制4.1在zookeeper容器内部新增节点一.Java连接Zookeeper1.创建Springboot工程，导入依赖org.springframework.bootspring-boot-start
    
                    
    • 
                    
  • springboot+es批量新增、批量修改、根据内部id批量查询
                        程序小增
elasticsearchspringbootjava
                        
    pom.xml配置org.elasticsearch.clientelasticsearch-rest-high-level-client7.8.0elasticsearchorg.elasticsearchelasticsearch-rest-clientorg.elasticsearch.clientorg.springframework.bootspring-boot-starter-dat
    
                    
    • 
                    
  • swagger-01-swagger介绍
                        褚师子书
swaggerjavaspringbootrestful
                        
    swagger1.学习目标：了解前后端分离了解Swagger的作用和概念在SpringBoot中集成Swagger1.1swagger由来前后端分离，当前流行的开发模式Vue+SpringBoot早先的后端时代：前端只用管理静态页面；后端将html用模板引擎JSP进行开发前后端分离式时代：后端：后端控制层，服务层，数据访问层【后端团队】前端：前端控制层，视图层【前端团队】mock后端数据json,
    
                    
    • 
                    
  • springboot生成二维码在word文档，并下载到本地
                        尼古拉骚
springboot+IO流javaspringjavascript
                        
    springboot生成二维码在word文档，并下载到本地分为两部分演示，第一部分简单的生成word文档并保存到本地；第二部分生成二维码在word文档，并保存到本地。第一部分首先引入word的依赖资源com.lowagieitext2.1.7com.lowagieitext-rtf2.1.7com.itextpdfitext-asian5.2.0创建Word，并且写入IO流中，前端获取文件流才能保
    
                    
    • 
                    
  • java.lang.NoClassDefFoundError: com/google/gson/Strictness
                        顽皮小书生
异常问题解决java
                        
    Springboot（版本3.4.0）项目引入Gson（版本2.10.1）包，启动一直报错报错内容java.lang.NoClassDefFoundError:com/google/gson/Strictnessatjava.base/java.lang.Class.getDeclaredFields0(NativeMethod)atjava.base/java.lang.Class.privat
    
                    
    • 
                    
  • 【微服务】SpringBoot 整合Redis Stack 构建本地向量数据库相似性查询
                        小码农叔叔
AI大模型实战与应用springboot入门到精通向量数据库redisstackjava使用向量数据库
                        
    目录一、前言二、向量数据库介绍2.1什么是向量数据库2.2向量数据库特点2.3向量数据库使用场景三、常用的向量数据库解决方案3.1Milvus3.1.1Milvus是什么3.1.2Milvus主要特点3.2Faiss3.2.1Faiss是什么3.2.2Faiss主要特点3.3Pinecone3.3.1Pinecone是什么3.3.2Pinecone主要特点3.4Weaviate3.4.1Weavi
    
                    
    • 
                    
  • 实际springboot项目中如何注意jvm调优
                        种豆走天下
springbootjvm后端
                        
    在SpringBoot项目中进行JVM调优是一个重要的任务，可以帮助提高应用程序的性能和稳定性。JVM调优可以涵盖内存管理、垃圾回收、线程管理以及其他JVM配置等多个方面。以下是一些常见的JVM调优策略，适用于SpringBoot应用：1.内存配置JVM的内存管理是影响SpringBoot应用性能的关键因素之一。你可以通过调整堆内存和非堆内存的大小来优化应用的性能。a.堆内存大小(-Xms和-Xm
    
                    
    • 
                    
  • SpringMVC的国际化
                        小胖子许愿
Springspring
                        
    SpringMVC的国际化WebMVC的核心LocaleResolver，MessageSource。WebMvcAutoConfiguration是SpringBoot中的Web方面的自动配置类。在MVC的配置类里面，如果没有自定义的LocaleResolver，那么就会使用默认的。并且自定义的名称是“localeResolver”，才不会加载默认的。默认使用的是AcceptHeaderLoca
    
                    
    • 
                    
  • Spring Boot整合Spring Security与JWT实现无状态认证：实战指南
                        老哥不老
笔记springspringboot数据库
                        
    SpringBoot整合SpringSecurity与JWT实现无状态认证：实战指南一、JWT认证原理简介JSONWebToken（JWT）是一种开放标准（RFC7519），由三部分组成：Header（头部）：声明令牌类型和签名算法Payload（负载）：携带用户身份信息Signature（签名）：防篡改验证认证流程：客户端提交登录凭证服务端验证通过后生成JWT客户端后续请求携带JWT服务端验证J
    
                    
    • 
                    
  • Spring Boot 集成海康SDK-Java：快速实现视频监控系统
                        伊勇发Drake

                        
    SpringBoot集成海康SDK-Java：快速实现视频监控系统【下载地址】SpringBoot集成海康SDK-JavaSpringBoot集成海康SDK-Java项目地址:https://gitcode.com/open-source-toolkit/1176a项目介绍在现代化的视频监控系统中，海康威视的设备广泛应用于各种场景。为了方便开发者快速集成海康SDK-Java到SpringBoot项
    
                    
    • 
                    
  • Spring Boot 消息队列（以RabbitMQ为例）
                        珠峰日记
java-rabbitmqspringbootrabbitmq
                        
    文章目录RabbitMQ简介与安装1.RabbitMQ简介2.RabbitMQ安装SpringBoot集成RabbitMQ1.创建SpringBoot项目2.配置RabbitMQ3.定义消息队列和交换机4.发送消息5.接收消息6.测试消息发送和接收RabbitMQ简介与安装1.RabbitMQ简介RabbitMQ是一个开源的消息代理和队列服务器，基于AMQP（高级消息队列协议）实现。它具有以下特点
    
                    
    • 
                    
  • 使用 Spring Boot 实现前后端分离的海康威视 SDK 视频监控
                        William Dawson
springboot
                        
    使用SpringBoot实现前后端分离的海康威视SDK视频监控系统，可以分为以下几个步骤：1.系统架构设计前端：使用Vue.js、React或Angular等前端框架实现用户界面。后端：使用SpringBoot提供RESTfulAPI，负责与海康威视SDK交互。通信：前后端通过HTTP/WebSocket进行通信。视频流：通过海康威视SDK获取视频流，并使用RTSP/RTMP/HLS等协议推送到前
    
                    
    • 
                    
  • Spring Boot 基础日志打印（Logback 在 application.yaml 文件中的配置）
                        我命由我12345
Java-简化库与框架编程springbootlogbackjava-eejavaintellij-idea后端spring
                        
    一、Logback在SpringBoot中，日志框架默认使用的是Logback，SpringBoot提供了对日志配置的简化SpringBoot默认会将日志输出到控制台，并且日志级别为INFO可以在application.yaml或application.properties文件中进行日志配置如果需要自定义日志配置，可以使用logback-spring.xml文件，SpringBoot会自动加载该文
    
                    
    • 
                    
  • SpringBoot 自动配置原理详解
                        蒂法就是我
springbootjavamybatis
                        
    SpringBoot的自动配置是其核心特性之一，它允许开发者通过最小化配置来快速启动应用程序。自动配置基于“约定优于配置”的原则，使得javer可以更专注于业务逻辑，而不必关注繁琐的配置。自动配置的基本工作原理SpringFactoriesSpringBoot利用META-INF/spring.factories文件来加载自动配置类。在这个文件里，有一个关键的入口org.springframewo
    
                    
    • 
                    
  • 【Spring Boot 接入 MongoDB】
                        龙少9543
后端springbootmongodb后端
                        
    【SpringBoot接入MongoDB】在SpringBoot项目中接入MongoDB是一个常见的需求，以下是详细的步骤和配置方法：1.添加依赖在pom.xml文件中添加SpringDataMongoDB的依赖。org.springframework.bootspring-boot-starter-data-mongodb如果你使用的是Gradle，可以添加以下内容：implementation
    
                    
    • 
                    
  • Spring Boot 切面执行优先级配置指南
                        蓝田～
springboot后端java
                        
    引言在SpringBoot应用开发中，切面编程（AOP）是一项强大的功能，它允许我们将横切关注点（如日志记录、事务管理、权限控制等）从业务逻辑中分离出来，以提高代码的可维护性和可扩展性。当存在多个切面时，了解和控制切面的执行优先级顺序就显得尤为重要。本文将深入介绍SpringBoot框架中切面执行优先级顺序的使用方式。切面优先级的概念在SpringAOP中，切面的优先级决定了多个切面在目标方法执行
    
                    
    • 
                    
  • SpringBoot对接外部API三大绝技：RestTemplate vs WebClient vs Feign，你Pick哪个？
                        墨瑾轩
一起学学Java【一】java
                        
    在SpringBoot应用中调用外部接口是常见的需求，通常用于集成第三方服务、微服务间通信等场景。以下是三种常用的调用外部接口的方式，包括代码示例和详细注释：1.使用RestTemplateRestTemplate是Spring提供的一个用于访问REST服务的客户端模板类，它简化了HTTP请求的处理过程。 Javaimportorg.springframework.beans.factory.an
    
                    
    • 
                    
  • springboot webflux webclient 使用示例
                        o_瓜田李下_o
webflux
                        
    springbootwebfluxwebclient使用示例************************示例HelloController@RestControllerpublicclassHelloController{@RequestMapping("/hello")publicMaphello(ServerWebExchangeexchange){exchange.getRequest(
    
                    
    • 
                    
  • 【Spring】WebClient之请求头设置、超时设置
                        九师兄
bootspringjavaspringboot
                        
    1.概述I.项目环境本项目借助SpringBoot2.2.1.RELEASE+maven3.5.3+IDEA进行开发1.依赖使用WebClient，最主要的引入依赖如下（省略掉了SpringBoot的相关依赖，如对于如何创建SpringBoot项目不太清楚的小伙伴，可以关注一下我之前的博文）org.springframework
    
                    
    • 
                    
  • springboot中Webclient对象怎么禁止缓存、保证每次数据都属来源后端
                        阿里嘎多学长
springboot缓存数据库
                        
    在SpringBoot中，使用WebClient对象进行HTTP请求时，可以通过配置请求头来禁止缓存，确保每次请求都能从后端获取最新的数据。以下是一些常用的方法来实现这一目的：设置Cache-Control请求头：在发起请求时，可以设置Cache-Control请求头为no-cache，这会告诉服务器和任何中间缓存，不应使用缓存的响应来满足请求。WebClientwebClient=WebClie
    
                    
    • 
                    
  • SpringBoot集成Sentry日志收集-2 (Sentry修改语言为中文)
                        欢乐少年1904
springbootsentry后端
                        
    Sentry修改成中文英文状态是不太友好,对于我这个英文不好的人来说,我用的一切开发软件,全是中文
    
                    
    • 
                    
  • 基于springboot+ollama实现大模型接入项目的小白笔记
                        河禾合和
springboot笔记后端llama
                        
    org.springframework.ai无法被maven加载的问题问题原因：阿里镜像没有这个库共用库中只保存了0.8.1的测试版本解决方法：参考了这个视频https://www.youtube.com/watch?v=dffEF9ORVUg学习视频中方法使用springinitializr这个工具进行项目的生成具体参数如下图在右边依赖中搜索ollama加载ai依赖，以及springweb依赖，
    
                    
    • 
                    
  • Spring Boot 缓存最佳实践：从基础到生产的完整指南
                        天才选手Yoke
javaspringbootspringboot缓存后端redis
                        
    SpringBoot缓存最佳实践：从基础到生产的完整指南引言在现代分布式系统中，缓存是提升系统性能的银弹。SpringBoot通过spring-boot-starter-cache模块提供了开箱即用的缓存抽象，但如何根据业务需求实现灵活、可靠的缓存方案？本文将带您从零开始，逐步构建符合生产要求的缓存系统。一、基础篇：5分钟快速接入1.1最小化配置pom.xml依赖org.springframewo
    
                    
    • 
                    
  • Spring Boot 3.0深度实战：从核心特性到生产级调优
                        Code_Cracke
Javaspringboot后端java
                        
    一、SpringBoot3.0核心特性解读1.1JDK17LTS支持（实测性能提升）记录类（Record）与SpringDataJPA完美适配模式匹配简化类型判断密封类（SealedClass）增强DTO安全性//使用Record优化DTOpublicrecordUserDTO(@NotBlankStringusername,@EmailStringemail){}//密封接口定义响应类型publ
    
                    
    • 
                    
  • MyBatis-Plus开发流程：Spring Boot + MyBatis-Plus 实现对 book_tab 表的增删改查及Redis缓存
                        Darling &you&
mybatis缓存springboot
                        
    前言MyBatis-Plus是一个MyBatis的增强工具，旨在简化开发、减少工作量。本文将介绍如何使用SpringBoot集成MyBatis-Plus来操作数据库，并结合Redis实现数据的缓存功能。1项目搭建1.1创建SpringBoot项目可以通过SpringInitializr快速创建一个新的SpringBoot项目，选择必要的依赖如SpringWeb,MyBatisPlus,MySQLD
    
                    
    • 
                    
  • Vue前后端参数传递（重要）
                        亭台烟雨中
vue前端springbootjsonvuejava
                        
    一般来说，大部分情况下springboot中controller只要参数名可以一一对应，就可以很方便的传递参数，但是如果前台给后台的参数非常复杂，涉及到多种类型，那么controller就无法智能的自动注入了letProdOBJ={"productCode":"155","productName":"产品-徐","productListCode":"list-xu","productListNam
    
                    
    • 
                    
  • 【项目实战】Spring AI集成DeepSeek实战指南（硅基流动平台版）
                        zxg45
AI大模型spring人工智能javadeepseek硅基流动AI大模型
                        
    SpringAI集成DeepSeek实战指南（硅基流动平台版）本文手把手教你通过SpringAI框架集成国产大模型DeepSeek，结合硅基流动平台实现智能对话功能。本方案支持普通对话和流式响应两种模式，完整代码已通过测试，可直接用于生产环境。一、环境准备开发工具JDK17+Maven3.9+SpringBoot3.2.x+（推荐3.3.0）硅基流动平台配置登录硅基流动官网,新用户赠送2000万t
    
                    
    • 
                    
  • springboot整合rabbitMQ
                        twx95
java-rabbitmqspringbootrabbitmq
                        
    安装rabbitMQ虚拟机或者服务器上安装我这里使用的是vm虚拟机做演示第一步：安装docker参考linux安装docker-CSDN博客第二步：拉取rabbitMQ镜像3-management（镜像版本）dockerpullrabbitmq:3-management查看镜像是否拉取成功dockerimages第三步：运行rabbitMQdockerrun\-eRABBITMQ_DEFAULT_
    
                    
    • 
                    
  • rabbitmq 手动提交_第四章----SpringBoot+RabbitMQ发送确认和消费手动确认机制
                        weixin_39622178
rabbitmq手动提交
                        
    1.配置RabbitMQ#发送确认spring.rabbitmq.publisher-confirms=true#发送回调spring.rabbitmq.publisher-returns=true#消费手动确认spring.rabbitmq.listener.simple.acknowledge-mode=manual2.生产者发送消息确认机制其实这个也不能叫确认机制，只是起到一个监听的作用，监
    
                    
    • 
                    
  • Spring Boot 异步编程
                        珠峰日记
springbootjava后端
                        
    文章目录一、异步方法的使用1.开启异步支持2.定义异步方法3.调用异步方法踩坑记录心得体会二、线程池配置1.自定义线程池2.使用自定义线程池踩坑记录心得体会三、异步任务的监控与管理1.日志记录2.异常处理3.线程池监控踩坑记录心得体会在现代应用程序开发中，异步编程是提升系统性能和响应能力的重要手段。SpringBoot提供了便捷的方式来实现异步编程，下面将详细介绍异步方法的使用、线程池配置以及异步
    
                    
    • 
                                
  • java观察者模式
                                    3213213333332132
java设计模式游戏观察者模式
                                    
    观察者模式——顾名思义，就是一个对象观察另一个对象，当被观察的对象发生变化时，观察者也会跟着变化。 
 
在日常中，我们配java环境变量时，设置一个JAVAHOME变量,这就是被观察者，使用了JAVAHOME变量的对象都是观察者，一旦JAVAHOME的路径改动，其他的也会跟着改动。 
 
这样的例子很多，我想用小时候玩的老鹰捉小鸡游戏来简单的描绘观察者模式。 
 
老鹰会变成观察者，母鸡和小鸡是
    
                                
    • 
                                
  • TFS RESTful API 模拟上传测试
                                    ronin47

                                    
           TFS RESTful API 模拟上传测试。 
　　 
细节参看这里：https://github.com/alibaba/nginx-tfs/blob/master/TFS_RESTful_API.markdown 
模拟POST上传一个图片： 
curl --data-binary @/opt/tfs.png http
    
                                
    • 
                                
  • PHP常用设计模式单例, 工厂, 观察者, 责任链, 装饰, 策略,适配,桥接模式
                                    dcj3sjt126com
设计模式PHP
                                    
    // 多态, 在JAVA中是这样用的, 其实在PHP当中可以自然消除, 因为参数是动态的, 你传什么过来都可以, 不限制类型, 直接调用类的方法
abstract class Tiger {
    public abstract function climb();
}

class XTiger extends Tiger {
    public function  climb()
    
                                
    • 
                                
  • hibernate
                                    171815164
Hibernate
                                    
    main,save 
 
Configuration conf =new Configuration().configure();
SessionFactory sf=conf.buildSessionFactory();
Session sess=sf.openSession();
Transaction tx=sess.beginTransaction();

News a=new 
    
                                
    • 
                                
  • Ant实例分析
                                    g21121
ant
                                    
            下面是一个Ant构建文件的实例，通过这个实例我们可以很清楚的理顺构建一个项目的顺序及依赖关系，从而编写出更加合理的构建文件。 
  
        下面是build.xml的代码： 
<?xml version="1
    
                                
    • 
                                
  • [简单]工作记录_接口返回405原因
                                    53873039oycg
工作
                                    
             最近调接口时候一直报错，错误信息是: 
      
responseCode:405
responseMsg:Method Not Allowed 
       接口请求方式Post. 
    
                                
    • 
                                
  • 关于java.lang.ClassNotFoundException 和 java.lang.NoClassDefFoundError 的区别
                                    程序员是怎么炼成的

                                    
      
 真正完成类的加载工作是通过调用 defineClass来实现的； 
 而启动类的加载过程是通过调用 loadClass来实现的； 
 就是类加载器分为加载和定义 
   
 protected Class<?> findClass(String name) throws ClassNotFoundExcept
    
                                
    • 
                                
  • JDBC学习笔记-JDBC详细的操作流程
                                    aijuans
jdbc
                                    
    所有的JDBC应用程序都具有下面的基本流程：　　1、加载数据库驱动并建立到数据库的连接。　　2、执行SQL语句。　　3、处理结果。　　4、从数据库断开连接释放资源。 
下面我们就来仔细看一看每一个步骤： 
其实按照上面所说每个阶段都可得单独拿出来写成一个独立的类方法文件。共别的应用来调用。 
1、加载数据库驱动并建立到数据库的连接： 
     Html代码    
 
 St
    
                                
    • 
                                
  • rome创建rss
                                    antonyup_2006
tomcatcmsxmlstrutsOpera
                                    
    引用   
1.RSS标准 
 
RSS标准比较混乱，主要有以下3个系列 
 
 RSS 0.9x / 2.0 : RSS技术诞生于1999年的网景公司(Netscape)，其发布了一个0.9版本的规范。2001年，RSS技术标准的发展工作被Userland Software公司的戴夫 温那(Dave Winer)所接手。陆续发布了0.9x的系列版本。当W3C小组发布RSS 1.0后，Dave W
    
                                
    • 
                                
  • html表格和表单基础
                                    百合不是茶
html表格表单meta锚点
                                    
    第一次用html来写东西,感觉压力山大,每次看见别人发的都是比较牛逼的 再看看自己什么都还不会, 
  
html是一种标记语言,其实很简单都是固定的格式 
  
_----------------------------------------表格和表单 
表格是html的重要组成部分,表格用在body里面的 
主要用法如下; 
<table>

     &
    
                                
    • 
                                
  • ibatis如何传入完整的sql语句
                                    bijian1013
javasqlibatis
                                    
            ibatis如何传入完整的sql语句？进一步说，String str ="select * from test_table"，我想把str传入ibatis中执行，是传递整条sql语句。 
        解决办法： 
<
    
                                
    • 
                                
  • 精通Oracle10编程SQL(14)开发动态SQL
                                    bijian1013
oracle数据库plsql
                                    
    /*
 *开发动态SQL
 */
--使用EXECUTE IMMEDIATE处理DDL操作
CREATE OR REPLACE PROCEDURE drop_table(table_name varchar2)
is
   sql_statement varchar2(100);
begin
   sql_statement:='DROP TABLE '||table_name;

    
                                
    • 
                                
  • 【Linux命令】Linux工作中常用命令
                                    bit1129
linux命令
                                    
    不断的总结工作中常用的Linux命令 
  
1.查看端口被哪个进程占用 
  
通过这个命令可以得到占用8085端口的进程号，然后通过ps -ef|grep 进程号得到进程的详细信息 
  
netstat -anp | grep 8085 
  
察看进程ID对应的进程占用的端口号 
  
netstat -anp | grep 进程ID 
&
    
                                
    • 
                                
  • 优秀网站和文档收集
                                    白糖_
网站
                                    
    集成 Flex, Spring, Hibernate 构建应用程序 
  
性能测试工具-JMeter 
  
Hmtl5-IOCN网站 
  
Oracle精简版教程网站 
  
鸟哥的linux私房菜 
  
Jetty中文文档 
  
50个jquery必备代码片段 
  
swfobject.js检测flash版本号工具
    
                                
    • 
                                
  • angular.extend
                                    boyitech
AngularJSangular.extendAngularJS API
                                    
    angular.extend   复制src对象中的属性去dst对象中. 支持多个src对象. 如果你不想改变一个对象，你可以把dst设为空对象{}: var object = angular.extend({}, object1, object2). 注意: angular.extend不支持递归复制.    使用方法:   angular.extend(dst, src);    参数:   
    
                                
    • 
                                
  • java-谷歌面试题-设计方便提取中数的数据结构
                                    bylijinnan
java
                                    
    网上找了一下这道题的解答，但都是提供思路，没有提供具体实现。其中使用大小堆这个思路看似简单，但实现起来要考虑很多。 
以下分别用排序数组和大小堆来实现。 
使用大小堆： 
 

import java.util.Arrays;

public class MedianInHeap {
	/**
	 * 题目：设计方便提取中数的数据结构
	 * 设计一个数据结构，其中包含两个函数，1.插
    
                                
    • 
                                
  • ajaxFileUpload 针对 ie jquery 1.7+不能使用问题修复版本
                                    Chen.H
ajaxFileUploadie6ie7ie8ie9
                                    
    jQuery.extend({
	handleError: function( s, xhr, status, e ) 		{
		// If a local callback was specified, fire it
				if ( s.error ) {
					s.error.call( s.context || s, xhr, status, e );
				}


    
                                
    • 
                                
  • [机器人制造原则]机器人的电池和存储器必须可以替换
                                    comsci
制造
                                    
     
 
       机器人的身体随时随地可能被外来力量所破坏,但是如果机器人的存储器和电池可以更换,那么这个机器人的思维和记忆力就可以保存下来,即使身体受到伤害,在把存储器取下来安装到一个新的身体上之后,原有的性格和能力都可以继续维持..... 
 
       另外,如果一
    
                                
    • 
                                
  • Oracle Multitable INSERT 的用法
                                    daizj
oracle
                                    
    转载Oracle笔记-Multitable INSERT 的用法 
 
http://blog.chinaunix.net/uid-8504518-id-3310531.html 
 
一、Insert基础用法 
 
语法： 
 
    Insert Into 表名 (字段1,字段2,字段3...） 
 
    Values (值1,
    
                                
    • 
                                
  • 专访黑客历史学家George Dyson
                                    datamachine
on
                                    
    20世纪最具威力的两项发明——核弹和计算机出自同一时代、同一群年青人。可是，与大名鼎鼎的曼哈顿计划（第二次世界大战中美国原子弹研究计划）相 比，计算机的起源显得默默无闻。出身计算机世家的历史学家George Dyson在其新书《图灵大教堂》（Turing’s Cathedral）中讲述了阿兰·图灵、约翰·冯·诺依曼等一帮子天才小子创造计算机及预见计算机未来
    
                                
    • 
                                
  • 小学6年级英语单词背诵第一课
                                    dcj3sjt126com
englishword
                                    
    always 总是 
rice 水稻，米饭 
before 在...之前 
live 生活，居住 
  
usual 通常的 
early 早的 
begin 开始 
month 月份 
  
year 年 
last 最后的 
east 东方的 
high 高的 
  
far 远的 
window 窗户 
world 世界 
than 比...更 
  
    
                                
    • 
                                
  • 在线IT教育和在线IT高端教育
                                    dcj3sjt126com
教育
                                    
    codecademy 
http://www.codecademy.com   codeschool 
https://www.codeschool.com   teamtreehouse 
http://teamtreehouse.com   lynda 
http://www.lynda.com/   Coursera 
https://www.coursera.
    
                                
    • 
                                
  • Struts2 xml校验框架所定义的校验文件
                                    蕃薯耀
Struts2 xml校验Struts2 xml校验框架Struts2校验
                                    
      
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 
蕃薯耀 2015年7月11日 15:54:59 星期六 
http://fa
    
                                
    • 
                                
  • mac下安装rar和unrar命令
                                    hanqunfeng
mac
                                    
    1.下载：http://www.rarlab.com/download.htm  选择 
RAR 5.21 for Mac OS X   2.解压下载后的文件   tar -zxvf rarosx-5.2.1.tar   3.cd rar   sudo install -c -o $USER unrar /bin #输入当前用户登录密码   sudo install -c -o $USER rar
    
                                
    • 
                                
  • 三种将list转换为map的方法
                                    jackyrong
list
                                    
      在本文中，介绍三种将list转换为map的方法： 
 
1） 传统方法 
 
假设有某个类如下 
   

class Movie {
    
    private Integer rank;
    private String description;
    
    public Movie(Integer rank, String des
    
                                
    • 
                                
  • 年轻程序员需要学习的5大经验
                                    lampcy
工作PHP程序员
                                    
    在过去的7年半时间里，我带过的软件实习生超过一打，也看到过数以百计的学生和毕业生的档案。我发现很多事情他们都需要学习。或许你会说，我说的不就是某种特定的技术、算法、数学，或者其他特定形式的知识吗？没错，这的确是需要学习的，但却并不是最重要的事情。他们需要学习的最重要的东西是“自我规范”。这些规范就是：尽可能地写出最简洁的代码；如果代码后期会因为改动而变得凌乱不堪就得重构；尽量删除没用的代码，并添加
    
                                
    • 
                                
  • 评“女孩遭野蛮引产致终身不育 60万赔偿款1分未得”医腐深入骨髓
                                    nannan408

                                    
    先来看南方网的一则报道： 
 

再正常不过的结婚、生子，对于29岁的郑畅来说，却是一个永远也无法实现的梦想。从2010年到2015年，从24岁到29岁，一张张新旧不一的诊断书记录了她病情的同时，也清晰地记下了她人生的悲哀。

　　粗暴手术让人发寒

　　2010年7月，在酒店做服务员的郑畅发现自己怀孕了，可男朋友却联系不上。在没有和家人商量的情况下，她决定堕胎。

　　12月5日，
    
                                
    • 
                                
  • 使用jQuery为input输入框绑定回车键事件 VS 为a标签绑定click事件
                                    Everyday都不同
jspinput回车键绑定clickenter
                                    
    假设如题所示的事件为同一个，必须先把该js函数抽离出来，该函数定义了监听的处理： 
  
function search() {
	//监听函数略......	
} 
  
为input框绑定回车事件，当用户在文本框中输入搜索关键字时，按回车键，即可触发search(): 
  
//回车绑定
$(".search").keydown(fun
    
                                
    • 
                                
  • EXT学习记录
                                    tntxia
ext
                                    
      
1. 准备 
  
（1） 官网：http://www.sencha.com/ 
  
里面有源代码和API文档下载。 
  
EXT的域名已经从www.extjs.com改成了www.sencha.com ，但extjs这个域名会自动转到sencha上。 
  
（2）帮助文档： 
  
想要查看EXT的官方文档的话，可以去这里h
    
                                
    • 
                                
  • mybatis3的mapper文件报Referenced file contains errors
                                    xingguangsixian
mybatis
                                    
    最近使用mybatis.3.1.0时无意中碰到一个问题： 
The errors below were detected when validating the file "mybatis-3-mapper.dtd" via the file "account-mapper.xml".  In most cases these errors can be d
    
                                
    •