一、注解(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,@ComponentScanpublic 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”)@ResponseBodypublic String test(){ return”ok”;}或者返回自定义的类型,如应用JsonResult类对数据后果进行封装:
@RequestMapping("/testDelete")@ResponseBodypublic 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注解形容的类, * 而后检测全局异样解决类中是否有适合的异样解决办法.如果如有则间接调用办法解决异样. * * 为什么要做全局异样解决?(提取共性) */@ControllerAdvicepublic 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@Aspectpublic 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@Componentpublic class SysLogAspect {}//定义缓存切面并指定优先级：@Order(2)@Aspect@Componentpublic 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容器启动时会创立线程池@SpringBootApplicationpublic class Application { public static void main(String[] args) { SpringApplication.run(Application.class, args); }} 在须要异步执行的业务办法上，应用@Async办法进行异步申明。
@Async@Transactional(propagation = Propagation.REQUIRES_NEW)@Overridepublic 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@Overridepublic 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@SpringBootApplicationpublic 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)@Overridepublic int saveObject(SysDept entity) {...}其中，allEntries示意革除所有。
文中局部内容摘自:www.cnblogs.com/tanwei81/p/6814022.html --作者：tanwei81