@Pointcut

@Pointcut //定义切面

@PointCut(...........)括号里面那些就是表达式。括号里支持的类型有：
execution: 匹配连接点

within: 某个类里面

this: 指定AOP代理类的类型

target:指定目标对象的类型

args: 指定参数的类型

bean:指定特定的bean名称，可以使用通配符（Spring自带的）

@target： 带有指定注解的类型

@args: 指定运行时传的参数带有指定的注解

@within: 匹配使用指定注解的类

@annotation:指定方法所应用的注解

@ResponseStatus

@ResponseStatus注解有两种用法，一种是加载自定义异常类上，一种是加在目标方法中

这里我们说一下加在目标方法上的这种情况，注解中有两个参数，value属性设置异常的状态码，reaseon是异常的描述，

需要重点注意的是不管该方法是不是发生了异常，将@ResponseStatus注解加在目标方法上，一定会抛出异常。但是如果没有发生异常的话方法会正常执行完毕。

我们可以使用@ResponseStatus标记带有状态码和应返回原因的方法或异常类。
在调用标记的处理程序方法时或引发指定的异常时，
HTTP状态将设置为使用@ResponseStatus批注定义的状态。

@TableLogic

@TableLogic //逻辑删除注解
private Integer deleted;

@version乐观锁

@Version //乐观锁version注解
private Integer version;

-------
  public class MyBatisPlusConfig {
    //注册乐观锁插件
    @Bean
    public OptimisticLockerInterceptor optimisticLockerInterceptor() {
        return new OptimisticLockerInterceptor();
    }

@TableField自动填充

//字段添加填充内容
@TableField(fill = FieldFill.INSERT)
private Date  createTime;
@TableField(fill = FieldFill.INSERT_UPDATE)
private Date  updateTime;


----
  @Slf4j
@Component //一定不要忘记把处理器加到ios容器中
public class MyMetaObjectHandler implements MetaObjectHandler {

    //插入时的填充策略
    @Override
    public void insertFill(MetaObject metaObject) {
        log.info("start insert fill............");
        //setFieldValByName(String fieldName, Object fieldVal, MetaObject metaObject)
        //fieldName:给那个字段传值，fieldVal：要传的值，metaObject，数据
        this.setFieldValByName("createTime",new Date(),metaObject);
        this.setFieldValByName("updateTime",new Date(),metaObject);


    }

    //更新时的填充策略
    @Override
    public void updateFill(MetaObject metaObject) {
        log.info("start update fill............");
        this.setFieldValByName("updateTime",new Date(),metaObject);

    }

@TableId，主键的生成策略

 //对应数据中的主键（uuid、自增id、雪花算法、redis、zookeeper）
    @TableId(type = IdType.AUTO)
    private Long id;@TableId(type = IdType.AUTO)


---------
  public enum IdType {
    AUTO,//数据库id自增
  NONE, //未设置主键
  INPUT,//手动输入 一旦选择就要手动输入id，不然为null
  ID_WORKER, //默认的全局唯一的id
  UUID, //全局唯一的id  uuid
  ID_WORKER_STR;//ID_WORKER 字符串表示法

@Transactional

@Transactional  事务管理

@EnableTransactionManagement

@EnableTransactionManagement  自动管理事务

@Entity、@Table、@Id、@GeneratedValue、@Column

@Entiy//告诉JPA这是一个实体类(和数据表映射的类)
@Table(name="xxx")//指定和一个数据表对应，如果省略，默认比表名就是类名小写


@Id//标注这是一个主键
@GeneratedValue(strategy=GenerationType.IDENTIY)//表示这是自增主键

@Column(name="xxx",length=xx) //表名这是和数据表对应的一个列,如果省略，默认列名就是属性名

@Mapper

/*
@Mapper注解是识别他为mybatis的mapper接口，会自动的把 加@Mapper 注解的接口生成动态代理类。
  
在spring中要实现dao的接口就是采用xxxxMapper.xml配置，在springboot中也要这样做，因为springboot
优化的是spring的配置文件


*/

@ConfigurationProperties

@ConfigurationProperties(prefix="")
绑定一个配置文件

@ControllerAdvice

//拦截所有标注着@Controller的控制器
@ControllerAdvice  //标准此注解，可以成为异常处理器

@ExceptionHandler

//自定义异常处理器
@ControllerAdvice  //标准此注解，可以成为异常处理器
public class MyExceptionHandler {

    @ExceptionHandler(UserNotExistException.class)  //标注要处理的异常（这里是自定义的异常 ）
    public String handleException(){

    }

@Bean

//给容器中添加组件，组件默认的id就是方法名
需要配合@Configuration 一起使用

<!--指定要扫描的包，这个包下的注解就会生效-->
<context:component-scan base-package="com.yuan"/>
<context:annotation-config/>

@Qualifier配合@Autowired使用

@Qualifier//自动装配(自动赋值)
直接上属性上使用即可！也可以在set方式上使用
  //也就是自定义类型，自动赋值，
  使用Autowired我们可以不用编写Ser方法，前提是这个自动装配的属性在IOC(Spring)容器中存在，且符合名字byname
  //如果显示定义了Autowired的required属性为false，说明这个对象可以为null，否则不允许为空
  public class People {
  @Autowired(required=false)
  private  Cat cat;
	@Autowired
	private  Dog dog;
/*
如果@Autowired自动装配的环境比较复杂，自动装配无法通过一个注解【@Autowired】完成的时候，
我们可以使用@Qualifier(value="xxx")去配置@Autowired的使用，指定一个bean对象注入
*/
<bean id="cat1" class="com.yuan.pojo.Cat"/>
<bean id="cat2" class="com.yuan.pojo.Cat"/>
<bean id="dog1" class="com.yuan.pojo.Dog"/>
<bean id="dog2" class="com.yuan.pojo.Dog"/>
<bean id="people" class="com.yuan.pojo.People"/>
  
  public class People {
  @Autowired
  @Qualifier(value = "cat1")
  private  Cat cat;
  @Autowired
  @Qualifier(value = "dog2")
  private  Dog dog;

@Component 衍生注解

@Component //可以单独使用，不用加@Bean也能表示他是一个Bean
public class User{
  @Value("这里是给name赋值")
  public String name;
}

相当于new对象的一个步骤
<bean id="user" class=...."User">
  <property name="name" value="一个值"/ >
  </bean>

/*
@Component 组件，放在类上，说明这个类被Spring管理了，就是bean！,注册到容器中了
- dao  【@Repository】 dao层的东西可以使用@Mapper来做出实现类
- service  【@Service】
- controller  【@Controller】

这四个注解功能都是一样的，都是代表将某个类注册到Spring中，装配Bean  
*/

@Value

@Component
public class User {

  //相当于 <property name="name" value="YuanYuan"/>
  @Value("YuanYuan")//属性注入值
  public String name;

@Scope作用域注解

@Component
@Scope("singleton")//prototype、request、session
public class User {

@Configuration

//指明当前类是一个配置类：就是来代替之前的spring配置文件,需要配合@Bean一起使用
//在配置文件中有用<bean>标签添加组件
//这个注解，也会被Spring容器托管，注册到容器中，因为他本来就是一个@Component
//@Configuration代表这个是一个配置类，就和之前看到的beans.xml是一样的
@Configuration
@ComponentScan("com.yuan.pojo")
@Import(YuanConfig2.class)
public class YuanConfig {
  
  //@Configuration标注在类上，
  //相当于把该类作为spring的xml配置文件中的< beans>，作用为：配置spring容器(应用上下文),
  
  //@Bean标注在方法上(返回某个实例的方法)，
  //等价于spring的xml配置文件中的< bean>，作用为：注册bean对象

@ComponentScan

//该注解默认会扫描该类所在的包下所有的配置类，
//相当于之前的 <context:component-scan>。

@Controller，控制器

@Controller //加入这个注解就会被视图解析器解析
public class AppController {
}	

//@Controller注解，说明该类是一个 Component

@Aspect

@Aspect //标注这个类是一个切面
public class AnnotationPointCut {
    @Before("execution(* com.yuan.service.UserServiceImpl.*(..))")
    public void before(){
        System.out.println("=======方法执行前===========");
    }

    @After("execution(* com.yuan.service.UserServiceImpl.*(..))")
     public  void after(){
         System.out.println("=======方法执行后===========");
     }

     //在环绕增强中，我们可以给定一个参数，代表我们要获取处理切入的点
     @Around("execution(* com.yuan.service.UserServiceImpl.*(..))")
     public void around(ProceedingJoinPoint jp) throws Throwable {
         System.out.println("环绕前");
         Signature signature = jp.getSignature();//获取签名
         System.out.println("signature"+signature);

         Object proceed = jp.proceed();//执行方法
         System.out.println("环绕后");

         System.out.println(proceed);
     }
}

@Before和@After

@Before("参数填入切面")  //如果切面是一个方法则填入方法()
在切面之前添加
  
  @BeAfter("参数填入切面")
  在切面之后添加

@AfterReturning

@AfterReturning("拦截的东西"，"切面")
在切面的方法执行完，返回之前
  
    @AfterReturning(returning =  "result",pointcut = "log()")
    public void doAfterRuturn(Object result){ //方法执行完，返回之后

    }

@Select，查询数据

@Select("select * from user where id=#{id}")
 User getUserById(@Param("id") int id);

@Insert，插入数据

@Insert("insert into user(id,name,pwd) values (#{id},#{name},#{password})")
    int addUser(User user);

@Update，更新数据

@Update("update user set name=#{name},pwd=#{password} where id=#{id}")
    int updateUser(User user);

@Delete，删除数据

@Delete("delete from user where id=#{uid}")
   int deleteUser(@Param("uid") int id);

@Param

- 基本类型的参数或者String类型，需要加上
- 引用类型不需要加
- 如果只有一个基本类型的话，可以忽略，但是建议加上
- 我们在SQL中引用的就是这理的@Param("")中设定的属性名

@Service

service

@Repository

dao

@GetMapping，PostMapping

@GetMapping("/add/{a}/{b}") //此注解可以设置提交的方式

@ResponseBody

@ResponseBody //添加次注解就不会走视图解析器，会直接返回字符串
public  String json1() throws JsonProcessingException {

@RequestBody

@RequestBody主要用来接收前端传递给后端的json字符串中的数据的(请求体中的数据的)
  GET方式无请求体，所以使用@RequestBody接收数据时，前端不能使用GET方式提交数据，而是用POST方式进行提交。

  在后端的同一个接收方法里，@RequestBody与@RequestParam()可以同时使用，@RequestBody最多只能有一个，而@RequestParam()可以有多个。

  简言之：

  一个请求——》只有一个@RequestBody；

  一个请求——》可以有多个@RequestParam。

@RequestMapping

@RequestMapping
 /*@RequestMapping(value = "/add/{a}/{b}",method = RequestMethod.GET)*/
  @RequestMapping("m1/t1")
//地址映射
//value：     指定请求的实际地址，指定的地址可以是URI Template 模式
//method：  指定请求的method类型， GET、POST、PUT、DELETE等；

@RestController

@RestController //标注这个注解下面的所有方法，只会返回json字符串，同时也不会走视图解析器
public class UserController {

@Autowired，使用注解实现自动装配，@Qualifier

@Autowired 
什么叫装配？就是给bean装配属性，方便该类调用此属性，装配就是设置属性的值
直接上属性上使用即可！也可以在set方式上使用
  使用Autowired我们可以不用编写Ser方法，前提是这个自动装配的属性在IOC(Spring)容器中存在，且符合名字byname
  //如果显示定义了Autowired的required属性为false，说明这个对象可以为null，否则不允许为空
  public class People {
  @Autowired(required=false)
  private  Cat cat;
	@Autowired
	private  Dog dog;
/*
如果@Autowired自动装配的环境比较复杂，自动装配无法通过一个注解【@Autowired】完成的时候，
我们可以使用@Qualifier(value="xxx")去配置@Autowired的使用，指定一个bean对象注入
*/
<bean id="cat1" class="com.yuan.pojo.Cat"/>
<bean id="cat2" class="com.yuan.pojo.Cat"/>
<bean id="dog1" class="com.yuan.pojo.Dog"/>
<bean id="dog2" class="com.yuan.pojo.Dog"/>
<bean id="people" class="com.yuan.pojo.People"/>
  
  public class People {
  @Autowired
  @Qualifier(value = "cat1")
  private  Cat cat;
  @Autowired
  @Qualifier(value = "dog2")
  private  Dog dog;

@Resource注解,使用注解自动装配

<bean id="cat1" class="com.yuan.pojo.Cat"/>
<bean id="cat2" class="com.yuan.pojo.Cat"/>

<bean id="dog1" class="com.yuan.pojo.Dog"/>
<bean id="dog2" class="com.yuan.pojo.Dog"/>
<bean id="people" class="com.yuan.pojo.People"/>
  
  public class People {
  @Resource(name = "cat2")
  private  Cat cat;
  @Resource(name = "dog1")
  private  Dog dog;
  private  String name;

@Resource 和 @Autowired 的区别：

/*
- 都是用来自动装配的都可以放在属性字段上
- @Autowired 通过byType的方式实现，而且必须要求这个对象存在【常用】
- @Resource  默认通过byName的方式实现，如果找不到名字，则通过byType实现，如果两个都找不到的情况，就报错【常用】
- 执行顺序不同@Autowired 通过byType的方式实现;@Resource  默认通过byName的方式实现
*/

@Nullable

字段标记了这个注解，说明这个字段可以为null;

@WebServlet

@WebServlet 
//选择Servlet的版本3.0以上,可以不创建web.xml
方法1		@WebServlet(urlPatterns = {"/资源路径"})
方法2		@WebServlet(value="/demo") 
方法3是方法2的简写，省略了value		@WebServlet("/资源路径")

-------------------------------------------
  /*
 <!-- 配置servlet-->
    <servlet>
        <servlet-name>demo</servlet-name>
        <servlet-class>servlet.TestServlet</servlet-class>
    </servlet>
    <servlet-mapping>
        <servlet-name>demo</servlet-name>
        <url-pattern>/demo</url-pattern>
    </servlet-mapping>
    
     */

@ConfigurationProperties 指定配置文件映射到类上使用

@ConfigurationProperties(prefix = "person")

#springboot这个配置文件中到底可以配置哪些东西呢？
person:
  name: yuanyuan
  age: 3
  happy: false
  birth: 2020/11/02
  maps: {k1: v1,k2: v2}
  lists:
    - code
    - music
    - girl
  Dog:
     name: 旺财
     age: 3

@PropertySource 加载指定的配置文件

@PropertySource(value = "classpath:diyname.properties")

@Validated，数格式校验，JSR303校验

@Validated//数格式校验
public class Person {
    @Email
    private String name;

没提示加入此依赖
<dependency>
  <groupId>org.springframework.boot</groupId>
  <artifactId>spring-boot-starter-validation</artifactId>
</dependency>

@EnableWebMvc

//@EnableWebMvc  //这个注解就是导入了一个类，DelegatingWebMvcConfiguration.class：从容器中获取所有的WebMVCconfig
//spring的其他自动装配将会失效

@PathVariable

@GetMapping("/emp/{id}")
   public String toUpdateEmp(@PathVariable("id") Integer id,Model model){
     //@PathVariable中的参数必须和跳转连接中的占位符一致

相信使用过springboot 的人都有用过@Configuration加上@Bean去注册一个bean 对象，这样我们就不用再去写xml文件去注册bean对象。 
而@Configuration标注在类上，相当于把该类作为spring的xml配置文件中的< beans>，作用为：配置spring容器(应用上下文), 
  @Bean标注在方法上(返回某个实例的方法)，等价于spring的xml配置文件中的< bean>，作用为：注册bean对象。 
  那使用xml注册bean对象和使用注解@Bean注册对象之间有什么明显的区别呢？
  比较明显的区别在于加载对象存在一定的先后顺序时会出现一个循环加载Bean的问题，
  容易出现在于使用动态数据源切换，继承AbstractRoutingDataSource实现的方法。为什么会出现这样的一种情况，
  这个就归结于springboot加载@Bean不是按照写代码的顺序加载的，
  解决的办法也是有的使用@Order注解的或者@Bean的方法上标识@DependsOn注解，
  来指定当前Bean实例化时需要触发哪些Bean的提前实例化。所以我还是建议在容易出现循环加载的地方使用xml配置文件初始化bean，
  然后在Application.class中添加上@ImportResource导入相应的xml文件。