杂记

idea注释的快捷键是什么

行注释快捷键：Ctrl+/

块注释：Ctrl +Shift+ /

方法说明注释：输入/**，再按“Enter”，自动根据参数和返回值生成注释模板

IDEA软件快捷键

如果你用的是idea软件，那就要换一个。
因为idea的ctrl+y是向下删除一行。

IDEA通用快捷键：
撤销：ctrl+z
取消撤销：ctrl+backspace
backspace就是回车上面那个经常用来删除的键位。

$axios

参考https://blog.csdn.net/m0_50570745/article/details/124019012

@Service注解

如果一个类带了@Service注解，将自动注册到Spring容器，不需要再在applicationContext.xml配置文件中定义bean了，类似的还包括@Component、@Repository、@Controller。

例：

@Service("courseDAO")
@Scope("prototype")
public class CourseDAOImpl extends HibernateDaoSupport implements CourseDAO{
......
}

其作用就相当于在applicationContext.xml配置文件里配置如下信息：

<bean id="courseDAO"
      class="com.study.persistent.CourseDAOImpl" scope="prototype">
      ......    
</bean>

@Service("serviceName")注解相当于applicationContext.xml配置文件中配置的<bean id="serviceName">，表示给当前类命名一个别名，方便注入到其他需要用到的类中。

@Service注解也可以不指定serviceName,如果不指定相当于<bean id="com.study.service.serviceName">，com.study.service.ServiceName就是这个类的全限定名,不加的话，默认别名就是当前类名，但是首字母小写。

spring2.5之后出现的注解，就跟在spring配置文件里配置bean差不多的功能，就是让spring自动扫描管理组件，@Service 、@Controller 、@Repository 、@Component ，这四个其实是一样的功能，没有区别，只是在MVC模式上表示的层不一样，service一般标注在service层的bean上，controller标注在控制层，@Repository标注在view层，component通用。

@Slf4j注解

@Slf4j是用作日志输出的，一般会在项目每个类的开头加入该注解。

添加了该注释之后，这样就省去这段很长的代码，就可以在代码中直接引用log.info( ) 打印日志了

@Configuration注解

@Configuration 用于定义配置类，可替换XML配置文件，被注解的类内部包含一个或多个@Bean注解方法。可以被AnnotationConfigApplicationContext或者AnnotationConfigWebApplicationContext 进行扫描。用于构建bean定义以及初始化Spring容器。

　　它是在spring3.0版本之后出现的。此注解是spring支持注解驱动开发的一个标志。表明当前类是spring的一个配置类，作用是替代spring的applicationContext.xml。但其本质就是@Component注解，被此注解修饰的类，也会被存入spring的IOC容器。

属性：
　　value:用于存入spring的ioc容器中Bean的id
使用场景:
　　在注解驱动开发时，用于缩写配置的类，通常可以使用此注解。一般情况下，我们的配置也会分为主次配置，@Configureation一般出现在主配置类上。值得注意的是，如果我们在注解驱动开发时，构建ioc容器使用的是传入字节码的构造函数，此注解可以省略，但是如果传入的是一个包，此注解则不能省略。

总结

• @Configuation等价于<Beans></Beans>
• @Bean 等价于<Bean></Bean>
• @ComponentScan等价于<context:component-scan base-package="com.dxz.demo"/>
• @Component 等价于<Bean></Bean>

SpringApplication.run()

启动类

@SpringBootApplication
public class DspApplication {
	public static void main(String[] args) {
		SpringApplication.run(DspApplication.class, args);
	}
}

这里run方法做了两件事：

1.创建SpringApplication对象

2.执行run方法

1.创建SpringApplication对象。SpringApplication.run()方法的基本调用流程：

public static ConfigurableApplicationContext run(Object source, String... args) {
		return run(new Object[] { source }, args);
} 
public static ConfigurableApplicationContext run(Object[] sources, String[] args) {
		return new SpringApplication(sources).run(args);
} 
public SpringApplication(Object... sources) {
		initialize(sources);
}

initialize方法：

private void initialize(Object[] sources) {
    
    // 在sources不为空时，保存配置类
    if (sources != null && sources.length > 0) {
        this.sources.addAll(Arrays.asList(sources));
    }
    
    // 判断是否为web应用
    this.webEnvironment = deduceWebEnvironment();
    
    // 获取并保存容器初始化类，通常在web应用容器初始化使用
    // 利用loadFactoryNames方法从路径MEAT-INF/spring.factories中找到所有的ApplicationContextInitializer
    setInitializers((Collection) getSpringFactoriesInstances(
        ApplicationContextInitializer.class));
    
    // 获取并保存监听器
    // 利用loadFactoryNames方法从路径MEAT-INF/spring.factories中找到所有的ApplicationListener
    setListeners((Collection) getSpringFactoriesInstances(ApplicationListener.class));
    
    // 从堆栈信息获取包含main方法的主配置类
    this.mainApplicationClass = deduceMainApplicationClass();
}

调用run方法

public ConfigurableApplicationContext run(String... args){
	
	//计时类，挺好用    
	StopWatch stopWatch = new StopWatch();
	stopWatch.start();
	
	// 声明一个Context容器
	ConfigurableApplicationContext context = null;
	FailureAnalyzers analyzers = 	null;
	configureHeadlessProperty();
	
	// 获取监听器
	// 利用loadFactoryNames方法从路径MEAT-INF/spring.factories中找到所有的SpringApplicationRunListener
	SpringApplicationRunListeners listeners = getRunListeners(args);
	
	// 调用监听器的启动
	// 调用每个SpringApplicationRunListener的starting方法
	listeners.started();
	try {
		
		// 将参数封装到ApplicationArguments对象中	
		ApplicationArguments applicationArguments = new DefaultApplicationArguments(args);
		
		// 创建并配置Environment（这个过程会加载application配置文件）
		// 触发监听事件——调用每个SpringApplicationRunListener的environmentPrepared方法
		ConfigurableEnvironment environment = prepareEnvironment(listeners, applicationArguments);
		  
		Banner printedBanner = printBanner(environment);
		
		// 根据应用类型创建对应的Context容器,是否为web环境创建web容器或者普通的IOC容器
		context = createApplicationContext();
		analyzers = new FailureAnalyzers(context);
		
		// 刷新Context容器之前的准备
		// 准备上下文
        // 1.将environment保存到容器中
        // 2.触发监听事件——调用每个SpringApplicationRunListeners的contextPrepared方法
        // 3.调用ConfigurableListableBeanFactory的registerSingleton方法向容器中注入applicationArguments与printedBanner
        // 4.触发监听事件——调用每个SpringApplicationRunListeners的contextLoaded方法
		prepareContext(context, environment, listeners, applicationArguments, printedBanner);
		
		// 刷新Context容器  
		refreshContext(context);
		
		// 刷新Context容器之后处理
		afterRefresh(context, applicationArguments);
		
		// Context容器refresh完毕发布
		listeners.finished(context, null);
		stopWatch.stop();
		if (logStartupInfo){
			new StartupInfoLogger(mainApplicationClass).logStarted(getApplicationLog(), stopWatch);
		}
		return context;
	}catch (Throwable ex) {
		handleRunFailure(context, listeners, analyzers, ex);
		throw new IllegalStateException(ex);
	}
}

总结

SpringApplication.run一共做了两件事：

1.创建SpringApplication对象：在对象初始化时保存事件监听器，容器初始化类以及判断是否为web应用，保存包含main方法的主配置类。
2.调用run方法：准备spring的上下文，完成容器的初始化，创建，加载等。会在不同的时机触发监听器的不同事件。

@TableField注解

@TableField 注解表示该字段是数据库字段，支持的属性包括：value、exist、el、condition、update、insertStrategy、updateStrategy、whereStrategy、fill。

其中，fill 属性就是用来设置自动填充策略的。FieldFill 是一个枚举类型，它定义了 4 种自动填充策略，分别为：

DEFAULT: 不进行任何填充
INSERT: 插入时填充
UPDATE: 更新时填充
INSERT_UPDATE: 插入和更新时都填充
当我们在实体类中使用 @TableField(fill = FieldFill.INSERT) 注解时，表示该字段在插入数据时会自动填充相应的值，而在更新数据时不会进行填充。

@Data注解

@Data注解的主要作用是提高代码的简洁，使用这个注解可以省去实体类中大量的get()、 set()、 toString()等方法。

简单来说就是不用再手动添加构造方法和get/set等方法了，大大提高了写代码的速度。

@Mapper注解

作用：在接口类上添加了@Mapper，在编译后会生成相应的接口实现类。

添加位置：在接口类上边。例：

@RestController注解

@RestController注解相当于@ResponseBody 和 @Controller合在一起的作用

要想明白 @RestController 的作用，首先需要明白@ResponseBody 和 @Controller 的作用。

@Controller ：将当前修饰的类注入 IOC 容器，使得从该类所在的项目跑起来的过程中，这个类就被实例化。同时也有语义化的作用，即代表该类是充当 Controller 的作用

@ResponseBody：它的作用就是指该类中所有的API接口返回的数据，不管你对应的方法返回 Map 或是其他Object，它会以 Json 字符串的形式返回给客户端

所以 @RestController注解其实就是将 return 中的内容以 JSON字符串的形式返回客户端

需要注意的是，如果要配合 sping-mvc 的视图解析器使用，也就是如果要返回 html 或者 jsp 时，就只能用 @Controller，因为当@Controller修饰的时候，Spring 才会认为返回的是一个 视图

@RequestMapping注解

作用：用于将任意HTTP 请求映射到控制器方法上。

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

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

在类的级别上的注解会将一个特定请求或者请求模式映射到一个控制器之上。之后你还可以另外添加方法级别的注解来进一步指定到处理方法的映射关系。

需要注意的是，控制器方法都应该映射到一个特定的HTTP方法，而不是使用@RequestMapping共享映射。

实例A：

@RestController
public class UserController {
		// 映射到方法上
		// localhost:8080/user/login
		// 此处通常用 @GetMapping("/user/login") 表明GET请求方式的映射，因为login登录只需向服务器获取用户数据。
    @RequestMapping("/user/login")  
    public String login() {
        return "user login";
    }
    
    // 映射到方法上
    // localhost:8080/user/register
    // 此处通常用 @PostMapping("/user/login") 表明POST请求方式的映射，因为register注册需要向服务器提交用户数据。
    @RequestMapping("/user/register")
    public String register() {
        return "user register";
    }
}

如上述代码所示，到 /user/login 的请求会由 login() 方法来处理，而到 /user/register的请求会由 register() 来处理。

实例B

@RestController
// 映射到类上
// localhost:8080/user
@RequestMapping("/user")
public class UserController {
		// 映射到方法上
		// localhost:8080/user/login
		// 此处通常用 @GetMapping("/user/login") 表明GET请求方式的映射
    @RequestMapping("/login") 
    public String login() {
        return "user login";
    }
    
    // 映射到方法上
    // localhost:8080/user/register
    // 此处通常用 @PostMapping("/user/login") 表明POST请求方式的映射
    @RequestMapping("/register")
    public String register() {
        return "user register";
    }
}

一般情况下，这样代码更规范，因为user的控制器UserController只对user表进行操作。

@Autowired注解

@Autowired可以标注在属性上、方法上和构造器上，来完成自动装配。默认是根据属性类型，spring自动将匹配到的属性值进行注入，然后就可以使用这个属性（对Springboot02WebApplicationTests类来说）autoWiredBean对象的方法。

它可以标注在属性上、方法上和构造器上，那有什么区别吗？简单来说因为类成员的初始化顺序不同，静态成员 ——> 变量初始化为默认值——>构造器——>为变量赋值。如果标注在属性上，则在构造器中就不能使用这个属性（对象）的属性和方法。

推荐： 对构造函数标注注解

直接应用于字段是我们使用的最多的一种方式，但是使用构造方法注入从代码层面却是更加好的。

当标注的属性是接口时，其实注入的是这个接口的实现类， 如果这个接口有多个实现类，只使用@Autowired就会报错，因为它默认是根据类型找，然后就会找到多个实现类bean，所有就不知道要注入哪个。然后它就会根据属性名去找。所以如果有多个实现类可以配合@Qualifier(value=“类名”)来使用 （是根据名称来进行注入的）

@PostMapping注解

@PostMapping注解用于处理HTTP POST请求，并将请求映射到具体的处理方法中。@PostMapping与@GetMapping一样，也是一个组合注解，它相当于是@RequestMapping(method=HttpMethod.POST)的快捷方式。

下面是使用@PostMapping的一个示例

@RequestController
@RequestMapping("/api/v1")
public class UserController{
    @Autowired
    private UserService userService;
    
    @PostMapping("/users")
    public User createUser(@Valid @RequestBody User user){
        return userService.save(user);
    }
}

@WebFilter注解

@WebFilter可用于将某个类设置为过滤器，该注解在tomcat的servlet包下，从servlet3.0版本就开始支持这个注解了。

该注解包含如下参数可以设置：

属性名	类型	说 明	其他
description	String	对该注解的说明
displayName	String	过滤器显示名，等同与<display-name>
initParams	WebInitParam[]	用于设置该过滤器类的一些初始化参数，等同于<init-param>	如：initParams = {@WebInitParam(name = "ignoredUrl", value = ".css#.js#.jpg#.png#.gif#.ico")
filterName	String	过滤器名，等价与<filter-name>
servletNames	String[]	String类型的数组，用于指定过滤的servlet。取值是 @WebServlet 中的 name 属性的取值，或者是 web.xml 中 <servlet-name> 的取值。
value，urlPatterns	String[]	过滤器的 URL 匹配模式。等价于 <url-pattern> 标签。	如： urlPatterns = {“/*”} 拦截所有，需要注意value和urlpattern只能选一个，建议urlpattern，好看些
dispatcherTypes	DispatcherType[]	过滤器的转发模式。具体取值包括：ASYNC、ERROR、FORWARD、INCLUDE、REQUEST。	有默认值，见上图，默认为request
asyncSupported	boolean	过滤器是否支持异步操作模式，等价于 <async-supported> 标签。	默认为false

此外，被@WebFilter注解的类，会在容器启动时被加载，并进行属性配置。即项目一启动容器自动加载init方法。

@ServletComponentScan注解

在SpringBootApplication上使用@ServletComponentScan注解后，Servlet、Filter、Listener可以直接通过@WebServlet、@WebFilter、@WebListener注解自动注册，无需其他代码。

@ComponentScan注解

Spring是一个依赖注入(dependency injection)框架。所有的内容都是关于bean的定义及其依赖关系。定义Spring Beans的第一步是使用正确的注解-@Component或@Service或@Repository.
但是，Spring不知道你定义了某个bean除非它知道从哪里可以找到这个bean.
ComponentScan做的事情就是告诉Spring从哪里找到bean。

包扫描会扫描只要标注了@Controller,@Service,@Repository,@Component这四个注解都会被扫描到容器中。
1、@Controller 控制器（注入服务）
用于标注控制层，相当于struts中的action层
2、@Service 服务（注入dao）
用于标注服务层，主要用来进行业务的逻辑处理
3、@Repository（实现dao访问）
用于标注数据访问层，也可以说用于标注数据访问组件，即DAO组件.
4、@Component （把普通pojo实例化到spring容器中，相当于配置文件中的）泛指各种组件，就是说当我们的类不属于各种归类的时候（不属于@Controller、@Service等的时候），我们就可以使用@Component来标注这个类。

@ResponseBody注解

将Controller的方法返回的对象,通过转换器转换为指定的格式之后,写入到 Response 对象的 body 区。用来返回 JSON 数据或 XML数据 。

注意：在使用此注解之后不会再走视图处理器，而是直接将数据写入到输入流中，他的效果等同于通过 Response 对象输出指定格式的数据 。

@ExceptionHandler注解

Spring的@ExceptionHandler可以用来统一处理方法抛出的异常，比如这样：

@ExceptionHandler()
public String handleExeption2(Exception ex) {
    System.out.println("抛异常了:" + ex);
    ex.printStackTrace();
    String resultStr = "异常：默认";
    return resultStr;
}

当我们使用这个@ExceptionHandler注解时，我们需要定义一个异常的处理方法，比如上面的handleExeption2()方法，给这个方法加上@ExceptionHandler注解，这个方法就会处理类中其他方法（被@RequestMapping注解）抛出的异常。

@ExceptionHandler注解中可以添加参数，参数是某个异常类的class，代表这个方法专门处理该类异常，比如这样：

@ExceptionHandler(NumberFormatException.class)
public String handleExeption(Exception ex) {
    System.out.println("抛异常了:" + ex);
    ex.printStackTrace();
    String resultStr = "异常：NumberFormatException";
    return resultStr;
}

此时注解的参数是NumberFormatException.class，表示只有方法抛出NumberFormatException时，才会调用该方法。

@Bean注解

Mybatis-plus LambdaQueryWrapper 模糊查询 like方法使用记录

//条件封装
QueryWrapper<FykUser> queryWrapper = new QueryWrapper<>();
queryWrapper.like(StringUtils.isNotBlank(user.getName()), "NAME", user.getName());
queryWrapper.like(user.getEnable() != null, "ENABLE", user.getEnable());
List<FykUser> userList = userDao.selectList(queryWrapper);

这里，like方法有三个参数：
第一个参数：该参数是一个布尔类型，只有该参数是true时，才将like条件拼接到sql中；本例中，如果name字段不为空，则拼接name字段的like查询条件；
第二个参数：该参数是数据库中的字段名；
第三个参数：该参数值字段值；
需要说明的是，这里的like查询是使用的默认方式，也就是说在查询条件的左右两边都有%：NAME = ‘%王%’；
如果只需要在左边或者右边拼接%，可以使用likeLeft或者likeRight方法。

queryWrapper.lt（）——小于
queryWrapper.le（）——小于等于
queryWrapper.gt（）——大于
queryWrapper.ge（）——大于等于
queryWrapper.eq（）——等于
queryWrapper.ne（）——不等于
queryWrapper.betweeen（“age”,10,20）——age在值10到20之间
queryWrapper.notBetweeen（“age”,10,20）——age不在值10到20之间
queryWrapper.like（“属性”,“值”）——模糊查询匹配值‘%值%’
queryWrapper.notLike（“属性”,“值”）——模糊查询不匹配值‘%值%’
queryWrapper.likeLeft（“属性”,“值”）——模糊查询匹配最后一位值‘%值’
queryWrapper.likeRight（“属性”,“值”）——模糊查询匹配第一位值‘值%’
queryWrapper.isNull（）——值为空或null
queryWrapper.isNotNull（）——值不为空或null
queryWrapper.in（“属性”，条件，条件 ）——符合多个条件的值
queryWrapper.notIn(“属性”，条件，条件 )——不符合多个条件的值
queryWrapper.or（）——或者
queryWrapper.and（）——和
queryWrapper.orderByAsc(“属性”)——根据属性升序排序
queryWrapper.orderByDesc(“属性”)——根据属性降序排序
queryWrapper.inSql(“sql语句”)——符合sql语句的值
queryWrapper.notSql(“sql语句”)——不符合SQL语句的值
queryWrapper.esists（“SQL语句”）——查询符合SQL语句的值
queryWrapper.notEsists（“SQL语句”）——查询不符合SQL语句的值

@TableField注解