1、@Retention
@Retention作用是定义被它所注解的注解保留多久，一共有三种策略，定义在RetentionPolicy枚举中.
从注释上看：
source：注解只保留在源文件，当Java文件编译成class文件的时候，注解被遗弃；被编译器忽略
class：注解被保留到class文件，但jvm加载class文件时候被遗弃，这是默认的生命周期
runtime：注解不仅被保存到class文件中，jvm加载class文件之后，仍然存在
这3个生命周期分别对应于：Java源文件(.java文件) ---> .class文件 ---> 内存中的字节码。
2、@JsonInclude
@JsonInclude(Include.NON_NULL)的作用：jackson 实体转json 为NULL的字段不参加序列化（即不显示）
3、@AllArgsConstructor
使用后添加一个构造函数，该构造函数含有所有已声明字段属性参数
@NoArgsConstructor
使用后创建一个无参构造函数
@AllArgsConstructor //生成全参数构造函数
@NoArgsConstructor//生成无参构造函数
4、@RestController
如果只有controller没有responseBody，服务器返回的是modelandview，前端并不能接收页面，所以要将返回值弄成实体，前端自己去解。
requestBody和requestParam传入的参数不一样，param是key-value形式。body是实体，传json数据。
注意事项
返回的对象里的属性必须拥有get方法，因为要进行数据转化,直接返回string时，不会进行json格式的转化
在Spring中@RestController的作用等同于@Controller + @ResponseBody。
所以想要理解@RestController注解就要先了解@Controller和@ResponseBody注解。
@Controller注解
在一个类上添加@Controller注解，表明了这个类是一个控制器类。但想要让这个类成为一个处理请求的处理器光有@Controller注解是不够的，他还需要进一步修炼才能成为一个处理器。
1.在spring容器中创建该类的实例。创建实例的方式有两种：
|
1
|
<bean class="test.controller.MyController" /> |
上述这种方式是在spring容器中注入单个bean，当项目比较大，控制器类比较多时，用这种方式向Spring容器中注入bean非常的让人苦恼，索性有第二种方式。
|
1
|
<context:component-scan base-scan="test.controller" /> |
这种方式会扫描指定包中的所有类，并生成相应的bean注入到spring容器中。使用这种方式当然能够极大提高我们的开发效率，但是有时候我们不想某一类型的类注入到spring容器中。
这个时候第二种方式也可以解决。
|
1
2
3
|
<context:component-scan base-package="test" > <context:include-filter type="annotation" expression="org.springframework.stereotype.Service"/></context:component-scan> |
上述代码表示扫描test包中除有@Service注解之外的类。
2.将@Controller注解的类注入Spring容器中，只是该类成为处理器的第一步，想要修炼大成，还需要在该类中添加注解@RequestMapping。
@RequestMapping注解是用来映射请求的，即指明处理器可以处理哪些URL请求，该注解既可以用在类上，也可以用在方法上。
当使用@RequestMapping标记控制器类时，方法的请求地址是相对类的请求地址而言的；当没有使用@RequestMapping标记类时，方法的请求地址是绝对路径。
@RequestMapping的地址可以是uri变量，并且通过@PathVariable注解获取作为方法的参数。也可以是通配符来筛选请求地址。
@ResponseBody注解
@ResponseBody表示方法的返回值直接以指定的格式写入Http response body中，而不是解析为跳转路径。
格式的转换是通过HttpMessageConverter中的方法实现的，因为它是一个接口，因此由其实现类完成转换。
如果要求方法返回的是json格式数据，而不是跳转页面，可以直接在类上标注@RestController，而不用在每个方法中标注@ResponseBody，简化了开发过程。
5、@ApiModel
使用场景：在实体类上边使用，标记类时swagger的解析类。
概述：提供有关swagger模型的其它信息，类将在操作中用作类型时自动内省。
@ApiModelProperty
使用场景：使用在被 @ApiModel 注解的模型类的属性上。表示对model属性的说明或者数据操作更改 。
概述：添加和操作模型属性的数据。
@ApiModelProperty()用于方法，字段； 表示对model属性的说明或者数据操作更改
value–字段说明
name–重写属性名字
dataType–重写属性类型
required–是否必填
example–举例说明
hidden–隐藏
6、@RestControllerAdvice
如果全部异常处理返回json，那么可以使用 @RestControllerAdvice 代替 @ControllerAdvice ，这样在方法上就可以不需要添加 @ResponseBody。
在spring 3.2中，新增了@ControllerAdvice 注解，可以用于定义@ExceptionHandler、@InitBinder、@ModelAttribute，并应用到所有@RequestMapping中。
@Target:注解的作用目标
@Target(ElementType.TYPE)——接口、类、枚举、注解@Target(ElementType.FIELD)——字段、枚举的常量@Target(ElementType.METHOD)——方法@Target(ElementType.PARAMETER)——方法参数@Target(ElementType.CONSTRUCTOR) ——构造函数@Target(ElementType.LOCAL_VARIABLE)——局部变量@Target(ElementType.ANNOTATION_TYPE)——注解@Target(ElementType.PACKAGE)——包
@Retention：注解的保留位置
RetentionPolicy.SOURCE:这种类型的Annotations只在源代码级别保留,编译时就会被忽略,在class字节码文件中不包含。RetentionPolicy.CLASS:这种类型的Annotations编译时被保留,默认的保留策略,在class文件中存在,但JVM将会忽略,运行时无法获得。RetentionPolicy.RUNTIME:这种类型的Annotations将被JVM保留,所以他们能在运行时被JVM或其他使用反射机制的代码所读取和使用。@Document：说明该注解将被包含在javadoc中@Inherited：说明子类可以继承父类中的该注解
@Transactional是声明式事务管理，编程中使用的注解
1、添加位置
1）接口实现类或接口实现方法上，并不是接口类中。
2）访问权限：public的方法才起作用，@Transactional注解应该只被应用到public方法上，由spring AOP的本质决定。
将标签放在需要事务管理的方法上，而不是放在所有接口实现类上，一些只读的接口就不需要事务管理，由于配置了@Transactional就需要AOP拦截及事务的处理，可能影响系统性能。
3）错误误区
一、接口中A、B两个方法。A没有@Tranc标签。B有，上层通过A间接调用B，事务不生效。
二、接口中异常（运行时异常）被捕获而没有抛出
默认配置下，spring只有在抛出的异常为运行时unchecked异常时 才会回滚该事务，也就是抛出的异常为RuntimeException的子类（Errors也会回滚）， 抛出check异常则不会导致事务回滚----可以通过@Transactional rollbackFor进行配置
三、多线程下事务管理因为线程不属于spring托管，故线程不能够默认使用spring事务，也不能获取spring注入的bean。
在被spring声明式事务管理的方法内开启多线程，多线程内的方法不被事务控制。
一个使用@Transactional的方法，如果方法内包含多线程的使用，方法内部出现异常，不会回滚到线程中调用方法的事务。
2、声明式事务管理实现方式：
基于tx和aop名字空间的xml配置文件
// 基本配置
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:context="http://www.springframework.org/schema/context"
xmlns:mvc="http://www.springframework.org/schema/mvc" xmlns:aop="http://www.springframework.org/schema/aop"
xmlns:task="http://www.springframework.org/schema/task" xmlns:jms="http://www.springframework.org/schema/jms"
xmlns:tx="http://www.springframework.org/schema/tx"
xsi:schemaLocation="http://www.springframework.org/schema/mvc http://www.springframework.org/schema/mvc/spring-mvc-4.1.xsd
http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-4.1.xsd
http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-4.1.xsd
http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-4.1.xsd
http://www.springframework.org/schema/task http://www.springframework.org/schema/task/spring-task-4.1.xsd
http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-4.1.xsd
http://www.springframework.org/schema/jms http://www.springframework.org/schema/jms/spring-jms-4.1.xsd">
<bean name="transactionManager"
class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
<property name="dataSource" ref="shardingDataSource"></property>
</bean>
<tx:annotation-driven transaction-manager="transactionManager" proxy-target-class="true" />
// MyBatis 自动参与到 spring 事务管理中，无需额外配置，
只要 org.mybatis.spring.SqlSessionFactoryBean 引用的数据源与
DataSourceTransactionManager 引用的数据源一致即可，否则事务管理会不起作用。
// <annotation-driven> 标签的声明，
是在 Spring 内部启用 @Transactional 来进行事务管理，使用 @Transactional 前需要配置。
3、@Transactional注解
1）实质是使用了JDBC的事务来进行事务控制的
2）基于spring的动态代理的机制
@Transactional 实现原理：
1) 事务开始时，通过AOP机制，生成一个代理connection对象，
并将其放入 DataSource 实例的某个与 DataSourceTransactionManager 相关的某处容器中。
在接下来的整个事务中，客户代码都应该使用该 connection 连接数据库，
执行所有数据库命令。
[不使用该 connection 连接数据库执行的数据库命令，在本事务回滚的时候得不到回滚]
（物理连接 connection 逻辑上新建一个会话session；
DataSource 与 TransactionManager 配置相同的数据源）
2) 事务结束时，回滚在第1步骤中得到的代理 connection 对象上执行的数据库命令，
然后关闭该代理 connection 对象。
（事务结束后，回滚操作不会对已执行完毕的SQL操作命令起作用）
4.声明式事务的管理实现本质：
事务的两种开启方式：
显示开启 start transaction | begin，通过 commit | rollback 结束事务
关闭数据库中自动提交 autocommit set autocommit = 0；MySQL 默认开启自动提交；通过手动提交或执行回滚操作来结束事务
Spring 关闭数据库中自动提交：在方法执行前关闭自动提交，方法执行完毕后再开启自动提交
// org.springframework.jdbc.datasource.DataSourceTransactionManager.java 源码实现
// switch to manual commit if necessary. this is very expensive in some jdbc drivers,
// so we don't want to do it unnecessarily (for example if we've explicitly
// configured the connection pool to set it already).
if (con.getautocommit()) {
txobject.setmustrestoreautocommit(true);
if (logger.isdebugenabled()) {
logger.debug("switching jdbc connection [" + con + "] to manual commit");
}
con.setautocommit(false);
}
问题：
关闭自动提交后，若事务一直未完成，即未手动执行 commit 或 rollback 时如何处理已经执行过的SQL操作？
C3P0 默认的策略是回滚任何未提交的事务
C3P0 是一个开源的JDBC连接池，它实现了数据源和 JNDI 绑定，支持 JDBC3 规范和 JDBC2 的标准扩展。目前使用它的开源项目有 Hibernate，Spring等
JNDI(Java Naming and Directory Interface,Java命名和目录接口)是SUN公司提供的一种标准的Java命名系统接口，JNDI提供统一的客户端API，通过不同的访问提供者接口JNDI服务供应接口(SPI)的实现，由管理者将JNDI API映射为特定的命名服务和目录系统，使得Java应用程序可以和这些命名服务和目录服务之间进行交互
-------------------------------------------------------------------------------------------------------------------------------
5. spring 事务特性
spring 所有的事务管理策略类都继承自 org.springframework.transaction.PlatformTransactionManager 接口
public interface PlatformTransactionManager {
TransactionStatus getTransaction(TransactionDefinition definition)
throws TransactionException;
void commit(TransactionStatus status) throws TransactionException;
void rollback(TransactionStatus status) throws TransactionException;
}
事务的隔离级别：是指若干个并发的事务之间的隔离程度
1. @Transactional(isolation = Isolation.READ_UNCOMMITTED)：读取未提交数据(会出现脏读,
不可重复读) 基本不使用
2. @Transactional(isolation = Isolation.READ_COMMITTED)：读取已提交数据(会出现不可重复读和幻读)
3. @Transactional(isolation = Isolation.REPEATABLE_READ)：可重复读(会出现幻读)
4. @Transactional(isolation = Isolation.SERIALIZABLE)：串行化
事务传播行为：如果在开始当前事务之前，一个事务上下文已经存在，此时有若干选项可以指定一个事务性方法的执行行为
1. TransactionDefinition.PROPAGATION_REQUIRED：
如果当前存在事务，则加入该事务；如果当前没有事务，则创建一个新的事务。这是默认值。
2. TransactionDefinition.PROPAGATION_REQUIRES_NEW：
创建一个新的事务，如果当前存在事务，则把当前事务挂起。
3. TransactionDefinition.PROPAGATION_SUPPORTS：
如果当前存在事务，则加入该事务；如果当前没有事务，则以非事务的方式继续运行。
4. TransactionDefinition.PROPAGATION_NOT_SUPPORTED：
以非事务方式运行，如果当前存在事务，则把当前事务挂起。
5. TransactionDefinition.PROPAGATION_NEVER：
以非事务方式运行，如果当前存在事务，则抛出异常。
6. TransactionDefinition.PROPAGATION_MANDATORY：
如果当前存在事务，则加入该事务；如果当前没有事务，则抛出异常。
7. TransactionDefinition.PROPAGATION_NESTED：
如果当前存在事务，则创建一个事务作为当前事务的嵌套事务来运行；
如果当前没有事务，则该取值等价于TransactionDefinition.PROPAGATION_REQUIRED。
上表字段说明：
1. value ：主要用来指定不同的事务管理器；
主要用来满足在同一个系统中，存在不同的事务管理器。
比如在Spring中，声明了两种事务管理器txManager1, txManager2.然后，
用户可以根据这个参数来根据需要指定特定的txManager.
2. value 适用场景：在一个系统中，需要访问多个数据源或者多个数据库，
则必然会配置多个事务管理器的
3. REQUIRED_NEW：内部的事务独立运行，在各自的作用域中，可以独立的回滚或者提交；
而外部的事务将不受内部事务的回滚状态影响。
4. ESTED 的事务，基于单一的事务来管理，提供了多个保存点。
这种多个保存点的机制允许内部事务的变更触发外部事务的回滚。
而外部事务在混滚之后，仍能继续进行事务处理，即使部分操作已经被混滚。
由于这个设置基于 JDBC 的保存点，所以只能工作在 JDB C的机制。
5. rollbackFor：让受检查异常回滚；即让本来不应该回滚的进行回滚操作。
6. noRollbackFor：忽略非检查异常；即让本来应该回滚的不进行回滚操作。
6.其他：
1. 事务方法的嵌套调用会产生事务传播。
2. spring 的事务管理是线程安全的
3. 父类的声明的 @Transactional 会对子类的所有方法进行事务增强；
子类覆盖重写父类方式可覆盖其 @Transactional 中的声明配置。
4. 类名上方使用 @Transactional，类中方法可通过属性配置来覆盖类上的 @Transactional 配置；
比如：类上配置全局是可读写，可在某个方法上改为只读。
如果不对运行时异常进行处理，那么出现运行时异常之后，要么是线程中止，要么是主程序终止。
如果不想终止，则必须捕获所有的运行时异常，决不让这个处理线程退出。队列里面出现异常数据了，正常的处理应该是把异常数据舍弃，然后记录日志。不应该由于异常数据而影响下面对正常数据的处理。
非运行时异常是RuntimeException以外的异常，类型上都属于Exception类及其子类。如IOException、SQLException等以及用户自定义的Exception异常。对于这种异常，JAVA编译器强制要求我们必需对出现的这些异常进行catch并处理，否则程序就不能编译通过。所以，面对这种异常不管我们是否愿意，只能自己去写一大堆catch块去处理可能的异常。