注解的作用.md · lifeAMan/MyNote

### Deprecated
定义在java.lang.Deprecated中，此注释可以用于修辞方法，属性，类，表示不鼓励程序员使用这样的元素，
通常是因为它很危险或者存在更好的选择

### SuppressWarnings
定义在java.lang.SuppressWarnings中,用来抑制编译时的警告信息（即使警告信息不显示）,与前两个注释有所不同,
你需要添加一个参数才能正确使用,这些参数都是已经定义好了的,我们选择性的使用就好了
@SuppressWarnings("all")
@SuppressWarnings("unchecked")
@SuppressWarnings(value=f"unchecked","deprecation"”)

### Pointcut
@Aspect标注的类中，通过@Pointcut定义切入点

### CacheEvict
主要针对方法配置，清楚缓存
有三个主要参数：\
value       缓存名称\
allEntries   是否清空所有缓存\
beforeInvocation    是否在方法执行前清空缓存，方法执行出错则不清除缓存

只清除一条缓存时，key为该条缓存名，

### CachePut
更新缓存
将本注解在修改数据库对应表数据的方法前，每次修改数据库后自动更新缓存
注意:更新缓存后要使更新缓存的方法返回原缓存的目标数据，否则会出现缓存数据无法读取的问题，同时key应为原缓存名

### Cacheable

此注解专门为了使用缓存

缓存的使用步骤：\
1、开启基于注解的缓存，使用 @EnableCaching 标识在 SpringBoot 的主启动类上。\
例：
```java
@MapperScan("com.hepingfly.springbootcach.mapper")
@SpringBootApplication
@EnableCaching     //开启基于注解的缓存
public class SpringbootCachApplication {
    public static void main(String[] args) {
        SpringApplication.run(SpringbootCachApplication.class, args);
    }
}
```
2、标注缓存注解即可
例：
```java
@Cacheable(cacheNames = "emps",key ="#id")   //#id 就表示取出参数 id 的值作为 key
public Employee getEmployee(Integer id) {
        System.out.printIn("查询" + id);
        Employee employee= employeeMapper.getEmpById(id);
        return employee;
}
```
注：这里使用 @Cacheable 注解就可以将运行结果缓存，以后查询相同的数据，直接从缓存中取，不需要调用方法。
没有参数时，key可以使用自定义名字，以单引号包裹后以双引号包裹，cacheNames可以自定义

注解常用属性：\
cacheNames/value ：用来指定缓存组件的名字\
key ：缓存数据时使用的 key，可以用它来指定。默认是使用方法参数的值。（这个 key 你可以使用 spEL 表达式来编写）\
keyGenerator ：key 的生成器。 key 和 keyGenerator 二选一使用\
cacheManager ：可以用来指定缓存管理器。从哪个缓存管理器里面获取缓存。\
condition ：可以用来指定符合条件的情况下才缓存\
unless ：否定缓存。当 unless 指定的条件为 true ，方法的返回值就不会被缓存。当然你也可以获取到结果进行判断。（通过 #result 获取方法结果）\
sync ：是否使用异步模式。

### @Inherited：
指定子类可以继承父类的注解，只能是类上的注解，方法和字段的注解不能继承。
即如果父类上的注解是@Inherited修饰的就能被子类继承。

### @Native：
指定字段是一个常量，其值引用native code。

### @Repeatable：
注解上可以使用重复注解，即可以在一个地方可以重复使用同一个注解，像spring中的包扫描注解就使用了这个。

### @Documented：
指定被标注的注解会包含在javadoc中。

### @Retention
指定注解的生命周期（源码、class文件、运行时）,
其参考值见类的定义：java.lang.annotation.RetentionPolicy

用法：@Retention(RetentionPolicy.SOURCE)
作用:表示被标注的注解只被保留在java源文件中

取值RetentionPolicy有\
SOURCE--->表示被标注的注解只被保留在java源文件中\
CLASS--->表示该注解被保存在class文件中\
RUNTIME--->表示该注解被保存在class文件中，并且可以被反射机制所读取

### @Target
指定注解使用的目标范围（类、方法、字段等），默认值value为任何元素，是最常见的元注解。

其参考值见类的定义：java.lang.annotation.ElementType

元注解是用来标注 注解类型 的注解。

为这个value传值：
Target(value={ElementType.FIELD})
被这个Target注解修饰的注解将只能作用在成员字段上，不能用于修饰方法或者类。
其中，ElementType是一个枚举类型，有以下一些值：\
@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)——包，用于记录java文件的package信息

#### Target使用：创建自定义注解

```java
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.FIELD)
public @interface MyAnnotation2{
    int[] value(); //自定义的属性
}
```

### @JsonIgnore

使前端忽略所注解的字段

### @TableField(exist=false)

标识字段，表示该字段在数据库中不存在

### @Alias

在myBatisConfig.xml中

sqlSessionFactory需要配置注解 需要扫的路径

```xml
<typeAliases>
    <package name="com.xxxxx.core"/>
</typeAliases>
```

Mybatis之typeAlias配置的3种方法

1.定义别名：
```xml
<typeAliases>
    <typeAlias alias="User" type="cn.lxc.vo.User" />
</typeAliases>
```

2.扫描包方式：
```xml
<typeAliases>
    <package name="cn.lxc.vo" />
</typeAliases>
```

3.注解方式：

```java
package cn.lxc.vo;
import org.apache.ibatis.type.Alias;
@Alias("User")
public class User {
    private int id;
    private String name;
    private int age;
    //getter and setter
}
```

### @RequestBody

@RequestBody主要用来接收前端传递给后端的json字符串中的数据的（前端表单对应的后端的类，负载），一般都用POST方式进行提交给方法。
在后端的同一个接收方法里，@RequestBody与@RequestParam()可以同时使用，@RequestBody最多只能有一个，而@RequestParam()可以有多个。

注：当同时使用@RequestParam（）和@RequestBody时，@RequestParam（）指定的参数可以是普通元素、
数组、集合、对象等等(即:当@RequestBody 与@RequestParam()可以同时使用时，原SpringMVC接收
参数的机制不变，只不过RequestBody 接收的是请求体里面的数据；而RequestParam接收的是key-value
里面的参数，所以它会被切面进行处理从而可以用普通元素、数组、集合、对象等接收)。
即：如果参数时放在请求体中，application/json传入后台的话，那么后台要用@RequestBody才能接收到；
如果不是放在请求体中的话，那么后台接收前台传过来的参数时，要用@RequestParam来接收，或
则形参前 什么也不写也能接收。

注：如果参数前写了@RequestParam(xxx)，那么前端必须有对应的xxx名字才行(不管其是否有值，当然可以通
过设置该注解的required属性来调节是否必须传)，如果没有xxx名的话，那么请求会出错，报400。

注：如果参数前不写@RequestParam(xxx)的话，那么就前端可以有可以没有对应的xxx名字才行，如果有xxx名
的话，那么就会自动匹配；没有的话，请求也能正确发送。
追注：这里与feign消费服务时不同；feign消费服务时，如果参数前什么也不写，那么会被默认是
@RequestBody的。

### @ResponseBody

简单地说：@ResponseBody注解将方法的返回值直接以JSON数据或者是XML数据的形式写入输出流，返回给前端。

@responseBody注解的作用是将controller的方法返回的对象通过适当的转换器转换为指定的格式之后，写入到response对象的body区，通常用来返回JSON数据或者是XML数据。
注意：在使用此注解之后不会再走视图处理器，而是直接将数据写入到输入流中，他的效果等同于通过response对象输出指定格式的数据。

@ResponseBody是作用在方法上的，@ResponseBody 表示该方法的返回结果直接写入 HTTP response body 中，一般在异步获取数据时使用【也就是AJAX】。
注意：在使用 @RequestMapping后，返回值通常解析为跳转路径，但是加上 @ResponseBody 后返回结果不会被解析为跳转路径，而是直接写入 HTTP response body 中。 比如异步获取 json 数据，加上 @ResponseBody 后，会直接返回 json 数据。@RequestBody 将 HTTP 请求正文插入方法中，使用适合的 HttpMessageConverter 将请求体写入某个对象。

@RequestBody 注解是将 HTTP 请求正文插入方法中，使用适合的 HttpMessageConverter 将请求体写入某个对象。
作用：
1) 该注解用于读取Request请求的body部分数据，使用系统默认配置的HttpMessageConverter进行解析，然后把相应的数据绑定到要返回的对象上；
2) 再把HttpMessageConverter返回的对象数据绑定到 controller中方法的参数上。

### @Transactional

简单的说：@Transactional注解一个public方法，在本类外调用该方法，将视该方法为原子方法，方法执行中出现异常，会回滚至方法执行前。
只是Spring事务管理的一部分。

##### Spring 的注解方式的事务实现机制
在应用系统调用声明@Transactional 的目标方法时，Spring Framework 默认使用 AOP 代理，在代码运行时生成一个代理对象，根据@Transactional 的属性配置信息，
这个代理对象决定该声明@Transactional 的目标方法是否由拦截器 TransactionInterceptor 来使用拦截，在 TransactionInterceptor 拦截时，
会在在目标方法开始执行之前创建并加入事务，并执行目标方法的逻辑, 最后根据执行情况是否出现异常，利用抽象事务管理器AbstractPlatformTransactionManager 操作数据源 DataSource 提交或回滚事务,

####  正确的设置@Transactional 的 propagation 属性
需要注意下面三种 propagation 可以不启动事务。本来期望目标方法进行事务管理，但若是错误的配置这三种 propagation，事务将不会发生回滚。

TransactionDefinition.PROPAGATION_SUPPORTS：如果当前存在事务，则加入该事务；如果当前没有事务，则以非事务的方式继续运行。
TransactionDefinition.PROPAGATION_NOT_SUPPORTED：以非事务方式运行，如果当前存在事务，则把当前事务挂起。
TransactionDefinition.PROPAGATION_NEVER：以非事务方式运行，如果当前存在事务，则抛出异常。
正确的设置@Transactional 的 rollbackFor 属性

##### 正确的设置@Transactional 的 rollbackFor 属性
默认情况下，如果在事务中抛出了未检查异常（继承自 RuntimeException 的异常）或者 Error，则 Spring 将回滚事务； 除此之外，Spring 不会回滚事务。
如果在事务中抛出其他类型的异常，并期望 Spring 能够回滚事务，可以指定 rollbackFor。例：
@Transactional(propagation= Propagation.REQUIRED,rollbackFor= MyException.class)
通过分析 Spring 源码可以知道，若在目标方法中抛出的异常是 rollbackFor 指定的异常的子类，事务同样会回滚。

##### @Transactional 只能应用到 public 方法才有效

##### 避免 Spring 的 AOP 的自调用问题
在 Spring 的 AOP 代理下，只有目标方法由外部调用，目标方法才由 Spring 生成的代理对象来管理，这会造成自调用问题。
若同一类中的其他没有@Transactional 注解的方法内部调用有@Transactional 注解的方法，有@Transactional 注解的方法的事务被忽略，不会发生回滚。

### @PathVariable 
映射 URL 绑定的占位符

通过 @PathVariable可以将 URL 中占位符参数绑定到控制器处理方法的入参中:URL 中的 {xxx} 占位符可以通过
@PathVariable(“xxx”) 绑定到操作方法的入参中。
一般与@RequestMapping(method = RequestMethod.GET)一起使用

1、若方法参数名称和需要绑定的url中变量名称一致时,可以简写:

```
@RequestMapping("/getUser/{name}")
public User getUser(@PathVariable String name){
    return userService.selectUser(name);
}
```
2、若方法参数名称和需要绑定的url中变量名称不一致时，写成:

```
@RequestMapping("/getUserById/{name}")
public User getUser(@PathVariable("name") String userName){
    return userService.selectUser(userName);
}
```

### @RequestMapping

表示共享映射，如果没有指定请求方式，将接收GET、POST、HEAD、OPTIONS、PUT、PATCH、
DELETE、TRACE、CONNECT所有的HTTP请求方式。@GetMapping、@PostMapping、@PutMapping、@DeleteMapping、
@PatchMapping 都是HTTP方法特有的快捷方式@RequestMapping的变体，分别对应具体的HTTP请求方式的映射注解。

@RequestMapping 注解可以在控制器类上和控制器类中的方法上使用。

### @RestController

@RestController 是 @Controller 和 @ResponseBody 两个注解的结合体。
源码如下：
```java
@Target({ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Controller
@ResponseBody
public @interface RestController {
    @AliasFor(
        annotation = Controller.class
    )
    String value() default "";
}
```
@Controller 与 @RestController应用场景
@Controller 一般应用在有返回界面的应用场景下.例如，管理后台使用了 thymeleaf 作为模板开发，需要从后台直接返回 Model 
对象到前台，那么这时候就需要使用 @Controller 来注解。

@RestController 如果只是接口，那么就用 RestController 来注解.例如前端页面全部使用了 Html、Jquery来开发，通过 Ajax 
请求服务端接口，那么接口就使用 @RestController 统一注解

### @Override
定义在java.lang.Override 中，
此注释只适用于修辞方法，表示此方法从父类继承，实现或重写父类同名方法。

### @Param

1.便于传多个参数；2.类似于别名之类的功能

dao层示例：
```
public User selectUser(@param("userName") String name, 
    @param("userpassword")String password);
```

对应的mapper.xml
```
select * from user_user_t where user_name = #{userName} and user_password=#{userPassword}
```
不使用@Param注解时，参数只能有一个，而且是JavaBean，在sql中只能引用JavaBean的属性。

但实际感觉，好像没什么用，传值需要形参，形参与实参名字可以不同，传参时使形参与实参不同名就可以实现别名的作用，而多个参数传递，不加param也可以实现，就，，，

### @Autowired

1.成员属性字段使用 @Autowired，无需字段的 set 方法（最常用）

2.set 方法使用 @Autowired
```
private ArticleService articleService;
@Autowired
public void setArticleService(ArticleService articleService) {
    this.articleService = articleService;
}
```
3.构造方法使用 @Autowired
```
private TagService tagService;
@Autowired
public TestController(TagService tagService) {
    this.tagService = tagService;
}
```
它是一个注释，它可以对类成员变量、方法及构造函数进行标注， 让 spring 完成 bean 自动装配的工作。
@Autowired 默认是按照类去匹配，配合 @Qualifier 指定按照名称去装配 bean。

### @Resouce

作用与@Autowired基本相同

@Resource有两个重要属性，分别是name和type
spring将name属性解析为bean的名字，而type属性则被解析为bean的类型。 
1. 如果使用name属性，则使用byName的自动注入策略，
2. 如果使用type属性，则使用byType的自动注入策略。 
3. 如果都没有指定，则通过反射机制使用byName自动注入策略。
4. 只是指定了@Resource注解的name，则按name后的名字去bean元素里查找有与之相等的name属性的bean。
5. 只指定@Resource注解的type属性，则从上下文中找到类型匹配的唯一bean进行装配，找不到或者找到多个，都会抛出异常
6. 既指定了@Resource的name属性又指定了type，则从Spring上下文中找到唯一匹配的bean进行装配，找不到则抛出异常

### @Qualifier

通过使用 @Qualifier 注解，我们可以消除@Autowired下自动装配时有多个满足要求的bean 的问题。

例如：
```java
@Component("fooFormatter")
public class FooFormatter implements Formatter {
    public String format() {
        return "foo";
    }
}

@Component("barFormatter")
@Primary                  //自动装配时，有多个符合条件的bean，默认优先使用带有@Primary的bean
public class BarFormatter implements Formatter {
    public String format() {
        return "bar";
    }
}
//@Component     
//public class FooService {     //运行时报错NoUniqueBeanDefinitionException
//    @Autowired
//    private Formatter formatter;
//    
//    //todo 
//}
@Component
public class FooService {     //运行时不报错
    @Autowired
    @Qualifier("fooFormatter")   //指定要装配的bean
    private Formatter formatter;

//todo 
}
```

### @Component

标注Spring管理的Bean，使用@Component注解在一个类上，表示将此类标记为Spring容器中的一个Bean。

@Controller 控制器层（注入服务），@Service 服务层（注入dao），
@Repository dao持久层（实现dao访问），都是基于@Component拓展的注解，使用方法与之相同，分别表示不同层的内容。

### 注解（Annotation）与反射
什么是注解？

Annotation是从JDK5.0开始引入的新技术
Annotation的作用:

不是程序本身，可以对程序作出解释(这一点和注释(comment)没什么区别)
    可以被其他程序(比如:编译器等)读取

Annotation的格式:
    
    注解是以“@注释名”在代码中存在的，还可以添加一些参数值，
    例:@SuppressWarnings(value="unchecked").

Annotation在哪里使用?

可以附加在package,class,method,field 等上面相当于给他们添加了额外的辅助信息
    我们可以通过反射机制编程实现对这些元数据的访问

@Override:定义在java.lang.Override 中，
@Deprecated:定义在java.lang.Deprecated中，此注释可以用于修辞方法，属性，类，
表示不鼓励程序员使用这样的元素，通常是因为它很危险或者存在更好的选择@SuppressWarnings:定义在java.lang.SuppressWarnings中,
用来抑制编译时的警告信息口与前两个注释有所不同, 你需要添加一个参数才能正确使用,这些参数都是已经定义好了的
我们选择性的使用就好了
@SuppressWarnings("all")
@SuppressWarnings("unchecked")
@SuppressWarnings(value=f"unchecked","deprecation"”)
等等.......

### 元注解
元注解的作用就是负责注解其他注解，Java定义了4个标准的meta-annotation类型,
他们被用来提供对其他annotation类型作说明
这些类型和它们所支持的类在java.lang.annotation包中可以找到.
(@Target,@Retention,Documented , @Inherited)

@Target:用于描述注解的使用范围(即:被描述的注解可以用在什么地方)
    
    @Retention:表示需要在什么级别保存该注释信息，用于描述注解的生命周期
    (SOURCE <CLASS < RUNTIME)
    
    @Document:说明该注解将被包含在javadoc中
    
    @Inherited:说明子类可以继承父类中的该注解
```java
//测试元注解
public class TestMetaAnnotations {
    @MyAnnototion
    public void test(){}
}
//定义一个注解
//Target 表示我们的注解可以用在哪些地方
@Target(value = {ElementType.METHOD,ElementType.TYPE})

//表示注解在什么地方还有效
@Retention(value = RetentionPolicy.CLASS)

//表示是否将注解生成在JavaDoc（文档）中
@Documented

//表示子类可以继承父类的注解
@Inherited
@interface MyAnnototion{
}
```

### 自定义注解
使用@interface自定义注解时，自动继承了java.lang.annotation.Annotation接口

分析

@interface用来声明一个注解，格式:public @interface 注解名{定义内容}
    其中的每一个方法实际上是声明了一个配置参数
    方法的名称就是参数的名称
    返回值类型就是参数的类型(返回值只能是基本类型class，String,enum)
    可以通过default来声明参数的默认值
    如果只有一个参数成员，一般参数名为value
    **注解元素必须要有值，我们定义注解元素时，经常使用空字符串,0作为默认值**???
```java
//自定义注解
public class TestCustomAnnotations {
    //注解可以显式赋值，如果没有默认值，我们必须给注解赋值
    //注解赋值没有顺序
    @CustomAnnotations(name="custom",schools = {"aaa"})
    public void test(){}
    @CustomAnnotation2("注解")
    public void test2(){}
}
@Target({ElementType.TYPE,ElementType.METHOD})
@Retention(RetentionPolicy.RUNTIME)
@interface CustomAnnotations{
    //注解的参数：参数类型+参数名() default+"默认值";
    String name() default "custom";
    int age() default 0;
    int id() default -1;  //默认值为-1，表示不存在
    String[] schools() default "没有学校";
}
@Target({ElementType.TYPE,ElementType.METHOD})
@Retention(RetentionPolicy.RUNTIME)
@interface CustomAnnotation2{
    //注解如果只有一个值，默认使用value，此时赋值时可省略value
    String value();
}
```

### 静态VS动态语言
动态语言 是一类在运行时可以改变其结构的语言:例如新的函数、对象、甚至代码可以被引进，
已有的函数可以被删除或是其他结构上的变化。通俗点说就是在运行时代码可以根据某些条件改变自身结构。
主要动态语言: Object-C、C#、JavaScript、PHP、Python等

静态语言 与动态语言相对应的，运行时结构不可变的语言就是静态语言。如Java、C、C++
Java不是动态语言，但Java可以称之为“准动态语言”。
即Java有一定的动态性我们可以利用反射机制获得类似动态语言的特性。

### Java Reflection（反射）
Reflection (反射)是Java被视为动态语言的关键，反射机制允许程序在执行期借助于
Reflection API取得任何类的内部信息，并能直接操作任意对象的内部属性及方法。

Class c = Class.forName(“java.lang.String”)

加载完类之后，在堆内存的方法区中就产生了一个Class类型的对象(一个类只有个Class对象)，
这个对象就包含了完整的类的结构信息。我们可以通过这个对象看到类的结构。
这个对象就像一面镜子，透过这个镜子看到类的结构，所以我们形象的称之为:反射
![Alt text](<图片/反射方式与正常方式.jpg>)

#### Java反射优点和缺点
优点

可以实现动态创建对象和编译，体现出很大的灵活性
缺点

对性能有影响。使用反射基本上是一种解释操作，我们可以告诉JVM，
    我们希望做什么并且它满足我们的要求。这类操作总是慢于直接执行相同的操作。

### Class类
在Obiect类中定义了以下的方法，此方法将被所有子类继承

public final Class getClass()

以上的方法返回值的类型是一个Class类，此类是Java反射的源头，
实际上所谓反射从程序的运行结果来看也很好理解，即:**可以通过对象求出类的名称**

通过反射可以得到的信息: 某个类的属性、方法和构造器、某个类到底实现了哪些接口。
对于每个类而言，JRE都为其保留一个不变的 Class 类型的对象。一个 Class 对象包含了特定某个结构
(class/interface/enum/annotation/primitive type/void/[])的有关信息

Class 本身也是一个类,对象只能由系统建立对象
一个加载的类在JVM 中只会有一个Class实例
一个Class对象对应的是一个加载到JVM中的一个.class文件
每个类的实例都会记得自己是由哪个Class实例所生成
通过Class可以完整地得到一个类中的所有被加载的结构
Class类是Reflection的根源，针对任何你想动态加载、运行的类，唯有先获得相应的Class对象
```java
//测试class类的创建方式有哪些
public class TestRE {
    public static void main(String[] args) throws ClassNotFoundException {
        Person person=new Student();
        System.out.println("这个人是："+person.name);
        //方式一：通过对象获得
        Class c1=person.getClass();
        System.out.println(c1.hashCode());
        //方式二：forName获得
        Class c2 = Class.forName("org.example.Reflection.Student");
        System.out.println(c2.hashCode());
        //方式三：通过类名.class获得
        Class<Student> c3=Student.class;
        System.out.println(c3.hashCode());
        //方式四：基本内置类型的包装类都有一个Type属性，
        Class<Integer> c4 = Integer.TYPE;
        System.out.println(c4);
        //获得父类类型
        Class c5 = c1.getSuperclass();
        System.out.println(c5);
    }
}
class Person{
    public String name;
    public Person(String name) {  this.name = name;    }
    @Override
    public String toString() {
        return "Person{" + "name='" + name + '\'' + '}';    }
}
class Student extends Person{
    public Student(){ this.name="学生"; }
}
```
注意：数组不管有多长，只要元素类型与维度相同，就是同一个class。
![Alt text](<图片/Java内存的堆栈与方法区.jpg>)

lifeAMan/MyNote

简介

发行版

贡献者

近期动态

lifeAMan/MyNote .gitee-modal { width: 500px !important; }

简介

发行版

贡献者

近期动态

搜索帮助

lifeAMan/MyNote