乐趣区

关于java:SpringBoot常用注解

jiezi

一、注解 (annotations) 列表
@SpringBootApplication：蕴含了 @ComponentScan、@Configuration 和 @EnableAutoConfiguration 注解。其中:@ComponentScan 让 SpringBoot 扫描到 Configuration 类并把它退出到程序上下文。
@Configuration 等同于 spring 的 XML 配置文件；应用 Java 代码能够查看类型平安。
@EnableAutoConfiguration 主动配置。
@ComponentScan 组件扫描，可主动发现和拆卸一些 Bean。
@Component 可配合 CommandLineRunner 应用，在程序启动后执行一些根底工作。
@RestController 注解是 @Controller 和 @ResponseBody 的合集, 示意这是个控制器 bean, 并且是将函数的返回值间接填入 HTTP 响应体中。
@Autowired 主动注入。
@PathVariable 获取参数。
@JsonBackReference 解决嵌套外链问题。
@RepositoryRestResourcepublic 配合 spring-boot-starter-data-rest 应用。

二、注解 (annotations) 详解
@SpringBootApplication：申明让 spring boot 主动给程序进行必要的配置，这个配置等同于：@Configuration，@EnableAutoConfiguration 和 @ComponentScan 三个配置。

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication//@Configuration,@EnableAutoConfiguration,@ComponentScan
public class Application {public static void main(String[] args) {SpringApplication.run(Application.class, args);
    }
}

@RequestMapping：提供路由信息，负责 URL 到 Controller 中的具体函数的映射。
@Controller：用于定义控制器类，在 spring 我的项目中由控制器负责将用户发来的 URL 申请转发到对应的服务接口（service 层），个别这个注解在类中，通常办法须要配合注解 @RequestMapping。
示例代码：

import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestMapping;
/**
 * 打算在这个 controller 中解决所有页面申请
 * @author ldjx
 */
@Controller
@RequestMapping("/")
public class PageController {
      // 返回我的项目的首页页面
    @RequestMapping("doIndexUI")
    public String doIndexUI() {return "index";}
}

@ResponseBody：示意该办法的返回后果间接写入 HTTP response body 中，个别在异步获取数据时应用。在应用 @RequestMapping 后，返回值通常解析为跳转门路，加上 @responsebody 后返回后果不会被解析为跳转门路，而是间接写入 HTTP response body 中。比方异步获取 json 数据，加上 @responsebody 后，会间接返回 json 数据。该注解个别会配合 @RequestMapping 一起应用。示例代码：

@RequestMapping(“/test”)
@ResponseBody
public String test(){return”ok”;}

或者返回自定义的类型, 如应用 JsonResult 类对数据后果进行封装:

@RequestMapping("/testDelete")
@ResponseBody
public JsonResult doDeleteObject(Integer id){
    //to delete...
    return new JsonResult("delete ok");
}

@RestController：用于标注管制层组件 (如 struts 中的 action)，@ResponseBody 和 @Controller 的合集。
示例代码：

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.ResponseBody;

import com.cy.pj.common.pojo.JsonResult;
import com.cy.pj.sys.service.SysLogService;
/**
 * 尽量将返回页面的申请解决与数据处理的 controller 离开
 * 只解决页面返回申请的应用 @controller 即可, 将 @RestController 应用在返回数据处理的 controller 上
 * 防止了每个办法上都加 @ResponseBody 的麻烦
 * @author ldjx
 */
@RestController // 相当于 @ResponseBody + @Controller
@RequestMapping("/test/")
public class SysLogController {

     @Autowired
     private TestService testService;
     
     @RequestMapping("doDeleteObject")
     public JsonResult doDeleteObjects(Integer id) {// 调用业务办法执行删除操作...( testService.doDelete(id) )
         return new JsonResult("delete ok");
     }
     @RequestMapping("doFindObjects")
     public JsonResult doFindPageObjects(){return new JsonResult(testService.findObjects());// 业务层返回的数据封装在 JsonResult 对象中
     }

@EnableAutoConfiguration：Spring Boot 主动配置（auto-configuration）：尝试依据你增加的 jar 依赖主动配置你的 Spring 利用。例如，如果你的 classpath 下存在 HSQLDB，并且你没有手动配置任何数据库连贯 beans，那么咱们将主动配置一个内存型（in-memory）数据库”。你能够将 @EnableAutoConfiguration 或者 @SpringBootApplication 注解增加到一个 @Configuration 类上来抉择主动配置。如果发现利用了你不想要的特定主动配置类，你能够应用 @EnableAutoConfiguration 注解的排除属性来禁用它们。
@ComponentScan：示意将该类主动发现扫描组件。集体了解相当于，如果扫描到有 @Component、@Controller、@Service 等这些注解的类，并注册为 Bean，能够主动收集所有的 Spring 组件，包含 @Configuration 类。咱们常常应用 @ComponentScan 注解搜寻 beans，并联合 @Autowired 注解导入。能够主动收集所有的 Spring 组件，包含 @Configuration 类。咱们常常应用 @ComponentScan 注解搜寻 beans，并联合 @Autowired 注解导入。如果没有配置的话，Spring Boot 会扫描启动类所在包下以及子包下的应用了 @Service,@Repository 等注解的类。
@Configuration：相当于传统的 xml 配置文件，如果有些第三方库须要用到 xml 文件，倡议依然通过 @Configuration 类作为我的项目的配置主类——能够应用 @ImportResource 注解加载 xml 配置文件。
@Import：用来导入其余配置类。
@ImportResource：用来加载 xml 配置文件。
@Service：个别用于润饰 service 层的组件
@Repository：应用 @Repository 注解能够确保 DAO 或者 repositories 提供异样转译，这个注解润饰的 DAO 或者 repositories 类会被 ComponetScan 发现并配置，同时也不须要为它们提供 XML 配置项。
@Value：注入 Spring boot application.properties 配置的属性的值。示例代码：
@Value(value = “#{message}”) private String message;
@Inject：等价于默认的 @Autowired，只是没有 required 属性；
@Component：泛指组件，当组件不好归类的时候，咱们能够应用这个注解进行标注。
@Bean：用 @Bean 标注办法等价于 XML 中配置的 bean, 放在办法的下面，而不是类，通知 Spring 容器，你能够从上面这个办法中拿到一个 Bean。
示例代码：

public class ObjectTest{ }
//------------------------------------------------------------------------------
/*
 * @Bean 注解通常会利用在一些配置类 (由 @Configuration 注解形容) 中, 用于形容
 * 具备返回值的办法, 而后零碎底层会通过反射调用其办法, 获取对象基于作用域将对象
 * 进行存储或利用。* @Bean 利用场景：第三方资源的整合及配置。*/
//@Bean("obj") // 为返回值指定名字
@Bean //Spring 容器中由 @Bean 形容的办法的返回值, 对应的名字默认为办法名
public ObjectTest testObj() {return new ObjectTest();
}

@AutoWired：主动注入依赖的 bean。byType 形式。把配置好的 Bean 拿来用，实现属性、办法的组装，它能够对类成员变量、办法及构造函数进行标注，实现主动拆卸的工作。当加上（required=false）时，就算找不到 bean 也不报错。
@Qualifier：当有多个同一类型的 Bean 时，能够用 @Qualifier(“name”)来指定。与 @Autowired 配合应用。@Qualifier 限定描述符除了能依据名字进行注入，但能进行更细粒度的管制如何抉择候选者，具体应用形式如下：

public interface TestQua { }
//----------------------------------------------------------------------------------------------------------
public class QuaImpl01 implements TestQua{ }
//----------------------------------------------------------------------------------------------------------
public class QuaImpl02 implements TestQua{ }
//----------------------------------------------------------------------------------------------------------
@SpringBootTest// 该注解用于 SpringBoot 我的项目中的测试类
public class CacheTest {
    //@Autowired 注解形容属性时, 零碎底层会基于属性类型从 spring 容器查找对象, 如果有多个类型都满足注入要求, 则还会基于属性名进行查找, 检测哪个 bean 名字与属性雷同, 如果有雷同的则间接取雷同进行注入, 没有则抛出异样
    @Autowired
    //@Qualifier 注解配合 @Autowired 注解应用, 用于指定将哪个 bean 的名字对应的对象注入给形容的属性
    //@Qualifier("quaImpl01")
    @Qualifier("quaImpl02")
    private TestQua testQua;
    @Test
    void testCache() {System.out.println("testQua="+testQua);
    }
}

@Resource(name=”name”,type=”type”)：没有括号内内容的话，默认 byName。与 @Autowired 干相似的事。
@Lazy: 形容 Spring 治理的 bean 对象时, 能够让 bean 提早构建和初始化.
提早加载 (懒加载, 按需加载) 利用场景:

大对象(例如一些池对象), 稀少用(例如容器初始化时创立了对象也用不到).

@Scope: 形容类时用于指定类实例的作用域, 罕用取值:

  • 1)singleton : 默认为单例作用域 - 类的实例在一个 JVM 内存中其实例只有一份, 此作用域通常还会配置 @Lazy 一起应用, 个别可重用对象可设计为单例, 对于这样的对象 spring 框架不仅仅负责其创立, 还会存储到 bean 池.
  • 2)prototype (多例作用域 - 此作用域对象何时须要何时创立,spring 框架不负责销毁)个别不可重用对象, 或者说只应用一次就不再用此对象了, 这样的对象就可设计为多例作用域.

@PostConstruct: 此注解形容的办法为生命周期初始化办法.
@PreDestroy: 此注解形容的办法为生命周期销毁办法, 此办法会在对象销毁之前执行 (如果是多例作用域, 则不会触发此办法).
示例代码:

@Scope //spring 容器中的 bean 没有应用 @Scope 注解形容时默认就是单例.
//@Scope("prototype")
@Lazy // 默认 value 属性值为 true, 示意此对象要提早构建及初始化.
//@Lazy(false)// 这里如果要写 false, 跟没有写 @Lazy 注解是一样的, 示意不反对对象提早构建及初始化.
@Component // 此注解形容 bean 示意这个 bean 对象会由 spring 创立, 其名字默认为类名, 首字母小写.
public class ObjectPool {//bean 的名字 objectPool
   public int size;
   public ObjectPool() {// 应用 lazy 注解后, 启动我的项目未触发构造方法, 阐明没有创立此对象(提早加载失效)
       System.out.println("ObjectPool()");
   }
   /**
    * @PostConstruct 此注解形容的办法为生命周期初始化办法
    * 在这样的办法中个别会为创立好的对象再此进行一些初始化.
    */
   @PostConstruct
   public void init() {System.out.println("init()");
   }
   /**
    *@PreDestroy 此注解形容的办法为生命周期销毁办法, 此办法会在对象销毁之前执行.
    * 在这样的办法中能够实现一些, 资源销毁操作.
    */
   @PreDestroy
   public void destory() {// 将对象从 bean 池中移除之前会执行此办法
      System.out.println("destory()");
   } 
}

三、JPA 注解
@Entity：@Table(name=””)：表明这是一个实体类。个别用于 jpa 这两个注解个别一块应用，然而如果表名和实体类名雷同的话，@Table 能够省略
@MappedSuperClass: 用在确定是父类的 entity 上。父类的属性子类能够继承。
@NoRepositoryBean: 个别用作父类的 repository，有这个注解，spring 不会去实例化该 repository。
@Column：如果字段名与列名雷同，则能够省略。
@Id：示意该属性为主键。
@GeneratedValue(strategy = GenerationType.SEQUENCE,generator = “repair_seq”)：示意主键生成策略是 sequence（能够为 Auto、IDENTITY、native 等，Auto 示意可在多个数据库间切换），指定 sequence 的名字是 repair_seq。
@SequenceGeneretor(name = “repair_seq”, sequenceName = “seq_repair”, allocationSize = 1)：name 为 sequence 的名称，以便应用，sequenceName 为数据库的 sequence 名称，两个名称能够统一。
@Transient：示意该属性并非一个到数据库表的字段的映射,ORM 框架将疏忽该属性。如果一个属性并非数据库表的字段映射, 就务必将其标示为 @Transient, 否则,ORM 框架默认其注解为 @Basic。@Basic(fetch=FetchType.LAZY)：标记能够指定实体属性的加载形式
@JsonIgnore：作用是 json 序列化时将 Javabean 中的一些属性疏忽掉, 序列化和反序列化都受影响。
@JoinColumn（name=”loginId”）: 一对一：本表中指向另一个表的外键。一对多：另一个表指向本表的外键。
@OneToOne、@OneToMany、@ManyToOne：对应 hibernate 配置文件中的一对一，一对多，多对一。

四、springMVC 相干注解
@RequestMapping：@RequestMapping(“/path”) 示意该控制器解决所有 ”/path” 的 UR L 申请。RequestMapping 是一个用来解决申请地址映射的注解，可用于类或办法上。
用于类上，示意类中的所有响应申请的办法都是以该地址作为父门路。该注解有六个属性：

  • 1)params: 指定 request 中必须蕴含某些参数值是，才让该办法解决。
  • 2)headers: 指定 request 中必须蕴含某些指定的 header 值，能力让该办法解决申请。
  • 3)value: 指定申请的理论地址，指定的地址能够是 URI Template 模式
  • 4)method: 指定申请的 method 类型，GET、POST、PUT、DELETE 等
  • 5)consumes: 指定解决申请的提交内容类型（Content-Type），如 application/json,text/html;
  • 6)produces: 指定返回的内容类型，仅当 request 申请头中的 (Accept) 类型中蕴含该指定类型才返回

@RequestParam：用在办法的参数后面。示例代码:

@RequestMapping("/test")
public String test(int userId) {// 当不应用 @RequestParam 注解时, 参数为非必传
    return "test";
}
//=========================================== 分隔线 =============================================== 
@RequestMapping("/test")
public String test(@RequestParam Integer id) {// 当应用 @RequestParam 注解时, 参数为必传, 且参数名为 id
    return "test";
}
//=========================================== 分隔线 ===============================================
@RequestMapping("/list")
public String test(@RequestParam(value = "userId", defaultValue = "0", required = false) int userId) {
    /*
     * value 值即申请参数的参数名；* required 该参数是否必须。默认为 true, 所以默认必传；* defaultValue 申请参数的默认值
     */
    return "list";
}

@PathVariable: 门路变量。如

//rest 格调 (软件架构编码格调, 这个格调中 url 的定义容许应用{} 作为变量)的 URL
//rest 格调的 url 劣势:
//1)能够更通用
//2)能够在异构平台下进行兼容
@RequestMapping("sys/{moduleUI}")
public String doModuleUI(@PathVariable String moduleUI) {return "sys/"+moduleUI;}

参数与大括号里的名字一样要雷同。
五、全局异样解决
@ControllerAdvice：蕴含 @Component。能够被扫描到。对立解决异样。
@ExceptionHandler（Exception.class）：用在办法下面示意遇到这个异样就执行以下办法。
@RestControllerAdvice:@ControllerAdvice+@ResponseBody
示例代码:

/**
 *     @ControllerAdvice 注解形容的类为 spring web(MVC)管制层的一个全局异样解决对象, 当管制层出现异常当前, 首先会检
 *  测管制层类中是否有异样解决办法, 如果没有或者不能解决以后异样, 则会查找是否有 @ControllerAdvice 注解形容的类,
 *  而后检测全局异样解决类中是否有适合的异样解决办法. 如果如有则间接调用办法解决异样.
 *
 *    为什么要做全局异样解决?(提取共性)
 */
@ControllerAdvice
public class GlobalExceptionHandler {
    /**
     * @ExceptionHandler 注解形容的办法为一个异样解决办法, 注解中定义的
     * 异样类型, 为以后办法的能够解决的异样解决类型(当然也能够解决异样类型的子类类
     * 型). 在异样解决办法中通常会定义一个异样参数, 来接管异样对象.
     */
    @ExceptionHandler(RuntimeException.class)
    @ResponseBody
    public JsonResult doHandleRuntimeException(RuntimeException e) {return new JsonResult(e);// 应用自定义 JsonResult 类对异样信息进行封装
    }
}

六、AOP 注解(AspectJ 框架)
@Aspect 注解用于标识或者形容 AOP 中的切面类型，基于切面类型构建的对象用于为指标对象进行性能扩大或控制目标对象的执行。
@Pointcut 注解用于形容切面中的办法，并定义切面中的切入点（基于特定表达式的形式进行形容）:

bean 表达式:
bean 表达式个别利用于类级别，实现粗粒度的切入点定义，案例剖析：

  • bean(“userServiceImpl”)指定一个 userServiceImpl 类中所有办法.
  • bean(“*ServiceImpl”)指定所有后缀为 ServiceImpl 的类中所有办法.

阐明:bean 表达式外部的对象是由 spring 容器治理的一个 bean 对象, 表达式外部的名字应该是 spring 容器中某个 bean 的 name.

within 表达式:
within 表达式利用于类级别，实现粗粒度的切入点表达式定义，案例剖析：

  • within(“aop.service.UserServiceImpl”)指定以后包中这个类外部的所有办法.
  • within(“aop.service.*”) 指定当前目录下的所有类的所有办法.
  • within(“aop.service..*”) 指定当前目录以及子目录中类的所有办法.

within 表达式利用场景剖析：

  • 1)对所有业务 bean 都要进行性能加强，然而 bean 名字又没有规定。
  • 2)按业务模块 (不同包下的业务) 对 bean 对象进行业务性能加强。

execution 表达式:
execution 表达式利用于办法级别，实现细粒度的切入点表达式定义，案例剖析：
语法：execution(返回值类型 包名. 类名. 办法名(参数列表)).

  • execution(void aop.service.UserServiceImpl.addUser())匹配 addUser 办法。
  • execution(void aop.service.PersonServiceImpl.addUser(String)) 办法参数必须为 String 的 addUser 办法.
  • execution(* aop.service..*.*(..)) 万能配置.

@annotation 表达式:
@annotaion 表达式利用于办法级别，实现细粒度的切入点表达式定义，案例剖析

  • @annotation(anno.RequiredTest) 匹配有此注解形容的办法。

其中:RequiredTest 为咱们本人定义的注解, 当咱们应用 @RequiredTest 注解润饰业务层办法时, 零碎底层会在执行此办法时进行咱们自定义的切面业务扩大操作(如主动将日志信息增加至数据库等操作)。

@Around 注解用于形容切面中办法，这样的办法会被认为是一个盘绕告诉（外围业务办法执行之前和之后要执行的一个动作），@Aournd 注解外部 value 属性的值为一个切入点表达式或者是切入点表达式的一个援用(这个援用为一个 @PointCut 注解形容的办法的办法名)。
ProceedingJoinPoint 类为一个连接点类型，此类型的对象用于封装要执行的指标办法相干的一些信息。只能用于 @Around 注解形容的办法参数。

AOP 编程的过程中，基于 AspectJ 框架规范，spring 中定义了五种类型的告诉 (告诉形容的是一种扩大业务)，它们别离是：
@Before
@AfterReturning
@AfterThrowing
@After
@Around(优先级最高)
如果这些告诉全副写到一个切面对象中，其执行程序及过程如下:

测试代码:

@Component
@Aspect
public class TestAspect {@Pointcut("bean(*ServiceImpl)")// 指定所有后缀为 ServiceImpl 的类中所有办法
    public void doTime(){}
    
    @Before("doTime()")
    public void doBefore(JoinPoint jp){System.out.println("time doBefore()");
    }
    @After("doTime()")
    public void doAfter(){System.out.println("time doAfter()");
    }
    @AfterReturning("doTime()")
    public void doAfterReturning(){System.out.println("time doAfterReturning");
    }

    @AfterThrowing("doTime()")
    public void doAfterThrowing(){System.out.println("time doAfterThrowing");
    }
    
    @Around("doTime()")
    public Object doAround(ProceedingJoinPoint jp)throws Throwable{System.out.println("doAround.before");
        try{Object obj = jp.proceed();
            System.out.println("doAround.after");
            return obj;
        }catch(Throwable e){System.out.println(e.getMessage());
            throw e;
        }
    }
}

对于 @AfterThrowing 告诉只有在出现异常时才会执行，所以当做一些异样监控时可在此办法中进行代码实现

@Order 注解用于形容切面的优先级，数字越小优先级越高, 默认值为整型的最大值, 所以默认优先级比拟低。
例如:

// 定义日志切面并指定优先级。@Order(1)
@Aspect
@Component
public class SysLogAspect {

}
// 定义缓存切面并指定优先级：@Order(2)
@Aspect
@Component
public class SysCacheAspect {//do something…}

Spring AOP 事务处理

基于 @Transactional 注解进行申明式事务管理的实现步骤分为两步：

  • 1. 启用申明式事务管理，在我的项目启动类上增加 @EnableTransactionManagement，新版本中也可不增加(例如新版 Spring Boot 我的项目).
  • 2. 将 @Transactional 注解增加到适合的业务类或办法上，并设置适合的属性信息.

其代码示例如下：

@Transactional(timeout = 30,readOnly = false,isolation = Isolation.READ_COMMITTED,
                rollbackFor = Throwable.class,propagation = Propagation.REQUIRED)
@Service 
public class SysUserServiceImpl implements SysUserService {@Transactional(readOnly = true)
    @Override
    public PageObject<SysUserDeptVo> findPageObjects(String name, Integer pageCurrent) {//do something…}
}

其中，代码中的 @Transactional 注解用于形容类或办法，通知 spring 框架咱们要在此类的办法执行时进行事务管制，其具体阐明如下：

  • 当 @Transactional 注解利用在类上时示意类中所有办法启动事务管理，并且个别用于事务共性的定义。
  • 当 @Transactional 形容办法时示意此办法要进行事务管理，如果类和办法上都有 @Transactional 注解，则办法上的事务个性优先级比拟高。

@Transactional 罕用属性利用阐明：

  • timeout：事务的超时工夫，默认值为 -1, 示意没有超时显示。如果配置了具体工夫, 则超过该工夫限度但事务还没有实现，则主动回滚事务。这个工夫的记录形式是在事务开启当前到 sql 语句执行之前。
  • read-only：指定事务是否为只读事务，默认值为 false；为了疏忽那些不须要事务的办法，比方读取数据，能够设置 read-only 为 true。对增加，批改，删除业务 read-only 的值应该为 false。
  • rollback-for：用于指定可能触发事务回滚的异样类型，如果有多个异样类型须要指定，各类型之间能够通过逗号分隔。
  • no-rollback- for: 抛出 no-rollback-for 指定的异样类型，不回滚事务。
  • isolation 事务的隔离级别，默认值采纳 DEFAULT。当多个事务并发执行时，可能会呈现脏读，不可反复读，幻读等景象时，如果不心愿呈现这些景象可思考批改事务的隔离级别(但隔离级别越高并发就会越小，性能就会越差).
    • *

Spring 业务的异步实现
在基于注解形式的配置中，借助 @EnableAsync 注解进行异步启动申明，Spring Boot 版的我的项目中，将 @EnableAsync 注解利用到启动类上，代码示例如下：

@EnableAsync //spring 容器启动时会创立线程池
@SpringBootApplication
public class Application {public static void main(String[] args) {SpringApplication.run(Application.class, args);
    }
}

在须要异步执行的业务办法上，应用 @Async 办法进行异步申明。

@Async
@Transactional(propagation = Propagation.REQUIRES_NEW)
@Override
public void saveObject(SysLog entity) {System.out.println("SysLogServiceImpl.save:"+Thread.currentThread().getName());
    sysLogDao.insertObject(entity);
    //try{Thread.sleep(5000);}catch(Exception e) {}}

如果须要获取业务层异步办法的执行后果，可参考如下代码设计进行实现：

@Transactional(propagation = Propagation.REQUIRES_NEW)
@Async
@Override
public Future<Integer> saveObject(SysLog entity) {System.out.println("SysLogServiceImpl.save:"+Thread.currentThread().getName());
    int rows=sysLogDao.insertObject(entity);
    //try{Thread.sleep(5000);}catch(Exception e) {}
    return new AsyncResult<Integer>(rows);
}

其中，AsyncResult 对象能够对异步办法的执行后果进行封装，如果外界须要异步办法后果时，能够通过 Future 对象的 get 办法获取后果。
当咱们须要本人对 spring 框架提供的连接池进行一些繁难配置，能够参考如下代码：

spring:
    task:
        execution:
            pool:
                queue-capacity: 128 #当来了新的工作, 外围线程都在忙, 如果队列还没有满, 则将工作先扔到队列
                core-size: 5 #定义外围线程数, 当池中线程没有达到这个值时, 每来一个工作都会创立一个新的线程.
                max-size: 128 #当外围线程数都在忙, 工作队列也满了, 再来新的工作在创立新的线程, 最多能够创立多少个由这个参数决定
                keep-alive: 60000 #当并发拜访高峰期过后, 有些线程可能会闲暇下来, 超出肯定的工夫, 线程要被开释, 这个工夫的指定由这个参数决定
            thread-name-prefix: service-task- #为池中的线程起个名字的前缀

Spring 中业务缓存利用实现
启动缓存配置
在我的项目 (SpringBoot 我的项目) 的启动类上增加 @EnableCaching 注解, 以启动缓存配置。代码如下：

//@EnableCaching 注解示意启动缓存配置
@EnableCaching
@SpringBootApplication
public class Application {public static void main(String[] args) {SpringApplication.run(Application.class, args);
    }
}

业务办法上利用缓存配置
在须要进行缓存的业务办法上通过 @Cacheable 注解对办法进行相干形容. 示意办法的返回值要存储到 Cache 中, 如果在更新操作时须要将 cache 中的数据移除, 能够在更新办法上应用 @CacheEvict 注解对办法进行形容：

@Cacheable(value = "menuCache")
@Transactional(readOnly = true)
public List<Map<String,Object>> findObjects() {//....}

其中，value 属性的值示意要应用的缓存对象, 名字本人指定，其中底层为一个 map 对象，当向 cache 中增加数据时，key 默认为办法理论参数的组合。
第二步：在相干模块更新时, 革除指定缓存数据, 代码如下:

@CacheEvict(value="menuCache",allEntries=true)
@Override
public int saveObject(SysDept entity) {...}

其中，allEntries 示意革除所有。

文中局部内容摘自:www.cnblogs.com/tanwei81/p/6814022.html – 作者：tanwei81

退出移动版