一、注解(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）：用在方法上面表示遇到这个异常就执行以下方法。
示例代码:
/**
* @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 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 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(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> 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