SpringBoot详细学习笔记

官网：Spring | Home | Spring Boot 下载：http://repo.spring.io/release/org/springframework/boot/

一、Spring4+和SpringBoot推荐使用Java配置(零配置)

Java配置方式主要是通过 @Configuration 和 @Bean 这两个注解实现的：

1. @Configuration 作用于类上，相当于一个xml配置文件,可理解为spring的xml里面的<beans>标签；

2. @Bean 作用于方法上，相当于xml配置中的<bean>；

3. @ComponentScan(basePackages="com.cssl") 扫描包

4. @PropertySource(value="classpath:mysql.properties")|@Value 读取配置文件

5. @EnableTransactionManagement 开启事务支持

6. @MapperScan("com.cssl.dao") 扫描dao包，产生代理对象

7. @EnableWebMvc 开启mvc支持

   a、新建类继承AbstractAnnotationConfigDispatcherServletInitializer，并重写getRootConfigClasses()、getServletConfigClasses()、getServletMappings()方法。

   public class MyConfiger extends AbstractAnnotationConfigDispatcherServletInitializer {
   ​
       @Override
       protected Class<?>[] getRootConfigClasses() {
           return new Class<?>[] {};
       }
   ​
       @Override
       protected Class<?>[] getServletConfigClasses() {
           return new Class<?>[] {WebConfig.class};
       }
   ​
       @Override
       protected String[] getServletMappings() {
           return new String[] {"/"};
       }
   ​
   }

   b、创建WebConfig实现WebMvcConfigurer接口

   @MapperScan("com.cssl.dao")             //扫描dao包，产生代理对象
   @EnableTransactionManagement            //开启事务支持
   @ComponentScan(basePackages="com.cssl") //扫描包
   @EnableWebMvc
   @Configuration
   public class WebConfig implements WebMvcConfigurer {
       
       /**
        * 配置springmvc视图
        * @return
        */
       /*@Bean
       public ViewResolver viewResolver(){
           InternalResourceViewResolver resolver = new InternalResourceViewResolver();
           resolver.setPrefix("/");
           resolver.setSuffix(".jsp");
           resolver.setExposeContextBeansAsAttributes(true);
           return resolver;
       }*/
   ​
       @Override
       public void configureViewResolvers(ViewResolverRegistry registry) {
             
           registry.viewResolver(new InternalResourceViewResolver("/", ".jsp"));
       }
       
       //<mvc:default-servlet-handler>,放开静态资源访问
       @Override
       public void configureDefaultServletHandling(DefaultServletHandlerConfigurer configurer) {
           configurer.enable();
       }
       
   }
   ​

   c、数据访问层

   @Configuration  //启动配置
   @PropertySource("classpath:mysql.properties")
   public class BaseDao {
       
       @Value("${jdbc.driver}")
       private String driver;      
       @Autowired
       private Environment env;
       
       @Bean("dataSource")
       public DataSource dataSource() {
           System.out.println("driver:"+driver);
           System.out.println("driver:"+env.getProperty("jdbc.driver"));
           
           DriverManagerDataSource ds = new DriverManagerDataSource();
           ds.setDriverClassName(driver);
           ds.setUrl(env.getProperty("jdbc.url"));
           ds.setUsername(env.getProperty("jdbc.username"));
           ds.setPassword(env.getProperty("jdbc.password"));
           return ds;
       }   
       
       @Bean
       public SqlSessionFactoryBean factory(DataSource dataSource) {
           SqlSessionFactoryBean factory = new SqlSessionFactoryBean();
           factory.setDataSource(dataSource);
           ResourcePatternResolver resolver = new PathMatchingResourcePatternResolver();
           Resource resource = resolver.getResource("classpath:mybatis-config.xml");
           factory.setConfigLocation(resource);
           
           return factory;
       }
   ​
       @Bean
       public DataSourceTransactionManager txManager(DataSource dataSource) {   
           return new DataSourceTransactionManager(dataSource);
       }
       
       @Bean
       public JdbcTemplate template(DataSource dataSource) {       
           return new JdbcTemplate(dataSource);
       }   
   }

   ---

二、SpringBoot入门

SpringBoot2 基于 Spring 5(Java 8)，支持 Java 9+，Maven 3.2+ SpringBoot2 针对Quartz调度器提供了支持。 SpringBoot2 基于Spring5构建，本次SpringBoot的升级，同时也升级了部分其依赖的第三方组件 主要的几个有： Tomcat 8.5+ Flyway 5+ 数据库版本控制 Hibernate 5.2+ ORM框架 Thymeleaf 3+ 模板引擎

SpringBoot3 基于 Spring 6(Java 17)，支持 Java 21，Maven 3.8+，Tomcat 10+

SpringBoot：解决Java开发繁多的配置，低下的开发效率、复杂的部署流程及很难集成第三方技术 优点： 1、快速构建项目 2、对主流开发框架无配置集成 3、独立运行，无需依赖外部容器 4、极大提高开发、部署效率 5、与云计算等的天然集成 6、SpringCloud天然搭档

Maven配置：

直接创建Maven项目或者使用插件自动创建springboot项目：

国外镜像	国内镜像
https://start.spring.io	https://start.aliyun.com
版本更新快，速度慢，全英文	速度快，中文，有MyBatisPlus等国内框架

1、设置spring boot的parent：包含了大量默认的配置，大大简化了我们的开发

<!-- 国外镜像 -->
<parent>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-parent</artifactId>
    <!-- <version>2.3.x.RELEASE</version> -->
    <version>2.4.x</version>
</parent>
​
<!-- 国内镜像 -->
<dependencyManagement>
    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-dependencies</artifactId>
            <version>${spring-boot.version}</version>
            <type>pom</type>
            <scope>import</scope>
        </dependency>     
    </dependencies>
</dependencyManagement>

Spring Boot 2.4.0 正式版本不再添加 RELEASE 后缀声明，支持JDK17，在这个版本中增加了大量的新特性和改进，尤其对配置文件改动是最大的并且还不向下兼容。

Spring Boot遵循的是Pivotal OSS支持策略，从发布日期起支持主要版本3年（注意：是主要版本）。下面是详情：Index of /spring-boot/docs{verion}/reference/htmlsingle/

• 3.0.x：支持的版本。2022.11发布，是目前最新的版本(Spring6.0.x JDK17-21)

• 2.7.x：支持的版本。2022.05发布，是2.x系列最后一个版本(Spring5.3.x JDK8-19)

• 2.6.x：支持的版本。2021.11发布，是现在的活跃的主干(Spring5.3.x JDK8-19)

• 2.5.x：支持的版本。2021.05发布，是现在的活跃的主干(Spring5.3.x JDK8-19)

• 2.4.x：支持的版本。2020.11发布，是现在的活跃的主干(Spring5.3.x JDK8-19)

• 2.3.x：支持的版本。2020.05发布，支持到2022.8月底，建议尽快升级(Spring5.2.x JDK8-15)

• 2.2.x：支持的版本。2019.10发布，支持到2021.8月底，建议尽快升级(Spring5.2.x JDK8-15)

• 2.1.x：2018.10发布，支持到2020.10月底，建议尽快升级

• 2.0.x：2018.3发布，2019.4.3停止维护，支持到2020.6

• 1.5.x：生命已终止的版本。2017.1发布，是最后一个1.x分支

2、导入spring boot的支持：核心SpringBoot starter，包括自动配置支持，日志和YAML (可选:可以通过spring-boot-starter-web传递依赖)

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter</artifactId>
</dependency>

3、导入spring boot的web支持：包括Tomcat、spring-webmvc，还自动依赖spring-boot-starter

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-web</artifactId>
</dependency>

4、添加Spring boot的插件：(可选:可以通过插件启动程序)

<plugin>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-maven-plugin</artifactId>
</plugin>

5、添加打war包插件：(可选:可以将项目打成war包发布)

<plugin>
    <artifactId>maven-war-plugin</artifactId>
    <version>3.0.0</version>
</plugin>

6、添加Spring boot对jsp|jstl的支持：(可选) 由于Spring boot使用的内嵌的tomcat，而内嵌的tomcat是不支持jsp页面的，需要导入额外的包才可以（Eclipse使用插件创建的工程只需手动创建webapp目录即可，不需要转web工程）

<!--添加对jsp的支持,否则不能识别<% %>|JSTL|EL-->
<dependency>
	<groupId>org.apache.tomcat.embed</groupId>
	<artifactId>tomcat-embed-jasper</artifactId>	
</dependency>
<!--添加对jstl的支持(TOMCAT9)-->
<dependency>
	<groupId>javax.servlet</groupId>
	<artifactId>jstl</artifactId>	
</dependency>
<!--添加对jstl的支持(TOMCAT10)-->
<dependency>
    <groupId>jakarta.servlet.jsp.jstl</groupId>
    <artifactId>jakarta.servlet.jsp.jstl-api</artifactId>	 
</dependency>	    
<dependency>
    <groupId>org.glassfish.web</groupId>
	<artifactId>jakarta.servlet.jsp.jstl</artifactId>
</dependency>

yml文件配置：(classpath | classpath\config | 项目根目录 | 项目根目录\config) 优先级

SpringBoot注解：

@SpringBootApplication：SpringBoot的核心注解，主要目的是开启自动配置，扫描本包及其子包bean @ConditionalOnXxx：条件注解 @ConfigurationProperties(prefix="") ：该注解将配置文件的值映射到类上，需要set方法 @SpringBootTest：SpringBoot的测试注解

@Import(Xxx.class)：导入其他类

@SpringBootApplication注解组合了以下注解： 1、@SpringBootConfiguration：继承自@Configuration，二者功能也一致，标注当前类是配置类， 并会将当前类内声明的一个或多个以@Bean注解标记的方法的实例纳入到spring容器中 2、@EnableAutoConfiguration：启用自动配置，该注解会使Spring Boot根据项目中依赖的jar包自动配置项目的配置项，如：我们添加了spring-boot-starter-web的依赖，项目就会引入SpringMVC的依赖，Spring Boot就会自动配置tomcat和SpringMVC 3、@ComponentScan：默认扫描@SpringBootApplication所在类的同级目录以及它的子目录

注意：如果手动添加了@ComponentScan，则原来的默认规则被覆盖，只使用手动添加的规则，如果不想手动扫描就可以利用@Import导入依赖。

如果想关闭某个自动配置： @SpringBootApplication(exclude=RedisAutoConfiguration.class)

或者：

spring:     
  autoconfigure:
    exclude:
      - org.springframework.boot.autoconfigure.jdbc.DataSourceAutoConfiguration

启动SpringBoot：SpringApplication.run(MainApp.class, args); 注意：主类必须放在包中，不能直接放java目录，否则异常

自定义Banner：

1、拷贝生成的字符到一个文本文件中，并且将该文件命名为banner.txt 2、将banner.txt(3.0前还可以使用banner.jpg|png|gif)拷贝到项目的resources(target)目录中，最终是要在target目录下， 3、如果不想看到banner，也可以将其关闭：spring.main.banner-mode =off

全局配置文件： Spring Boot项目使用一个全局的配置文件application.properties或者是application.yml，在resources目录下

访问静态资源：进入规则为 / 如果进入SpringMVC的规则为/时，Spring Boot的默认静态资源的路径为： classpath:/META-INF/resources/,classpath:/resources/,classpath:/static/,classpath:/public/

也可以通过Spring指定：

spring.mvc.static-path-pattern=/**
spring.resources.static-locations=classpath:/templates/     #2.4前
spring.web.resources.static-locations=classpath:/templates/ #2.4后

yml:

spring:
  mvc:
    static-path-pattern: /**
  #resources: #2.4前
      #static-locations: classpath:/
  web:
  	resources:
      static-locations: classpath:/templates/,classpath:/META-INF/resources/,classpath:/resources/,classpath:/static/,classpath:/public/

注意： 1、指定后默认的就失效了 2、配置了templates则可以直接访问模板文件，否则只能通过controller转发 3、templates下的模板也可以链接static下的css、js等静态资源，反之也可以 4、无论什么时候都不能重定向访问模板文件，因为重定向不使用模板视图解析器 5、没有配置视图解析如果使用post请求，不支持转发只能重定向

热部署（修改代码自动部署） 导入依赖:(加入热部署后main方法中启动语句run()前输出语句会执行两次)

<dependency>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-devtools</artifactId>
</dependency>

修改idea设置(见设置文档或教材)

加载配置文件中的参数

获取application.yml（或application.properteis）文件中的配置信息

1、使用@Value注解

user:
  username: admin
  password: 123

@Component
@Data
public class User {
	private Integer id;
	@Value("${user.username}")
	private String username;
	@Value("${user.password}")
	private String password;	
}

2、使用@ConfigurationProperties注解

uservo:
  username: 管理员
  password: 123

@Component
//@EnableConfigurationProperties(UserVo.class) 这个不用，否则产生两个bean
@ConfigurationProperties(prefix = "uservo") //下面依赖不引入会有警告，不配也能用
@Data
public class UserVo {

	private Integer id;
	private String username;	
	private String password;
}

<dependency>
	<groupId>org.springframework.boot</groupId>
	<artifactId>spring-boot-configuration-processor</artifactId>
	<optional>true</optional>
</dependency>

多环境配置

bootstrap.yml、application.yml、application-dev.yml、application-test.yml... ...

bootstrap.yml 优先级高，一般用于进程内资源初始化相关配置

注意： 1、如果新增的配置文件没有显示成springboot配置(绿叶)：Project Settings->Spring->绿叶->Configuration Files->+ 2、springboot指定环境必须在application.xxx配置，bootstrap.yml配置无效(cloud有效)

spring:
  profiles:
    active: dev

3、properties优先级高于yml文件，当配置有冲突时根据优先级高的决定

---

三、SpringBoot和MyBatis整合：

第一种：使用mybatis-spring整合的方式，也就是我们传统的方式

优点：我们可以手动控制MyBatis的各种配置

导入依赖

<dependency>
	<groupId>org.mybatis</groupId>
	<artifactId>mybatis</artifactId>
	<version>3.5.x</version>
</dependency>	
<dependency>
	<groupId>org.mybatis</groupId>
	<artifactId>mybatis-spring</artifactId>
	<version>x.x.x</version>
</dependency>

使用lombok：(jdk9以上版本需要1.16.21以上版本，不写版本自动匹配springboot版本，越新的jdk需要越新的lombok)

<dependency>
      <groupId>org.projectlombok</groupId>
      <artifactId>lombok</artifactId>
      <version>1.18.16</version>
</dependency>

1、创建Mybatis的配置类：

@Configuration
public class MyBatisConfiger {
    @Autowired
    private Environment env;

    @Bean
    public DataSource dataSource() {
        DriverManagerDataSource ds = new DriverManagerDataSource();
        ds.setDriverClassName(env.getProperty("jdbc.driver"));
        ds.setUrl(env.getProperty("jdbc.url"));
        ds.setUsername(env.getProperty("jdbc.username"));
        ds.setPassword(env.getProperty("jdbc.password"));
        return ds;
    }	

    @Bean
    @ConditionalOnMissingBean 
    public SqlSessionFactoryBean sqlSessionFactory(){
        SqlSessionFactoryBean factory = new SqlSessionFactoryBean();
        factory.setDataSource(dataSource);
        ResourcePatternResolver resolver = new PathMatchingResourcePatternResolver();
        Resource resource = resolver.getResource("classpath:mybatis-config.xml");
        factory.setConfigLocation(resource);
        return factory;
    }
}

2、创建Mapper接口的扫描类MapperScannerConfig：

@Configuration
@AutoConfigureAfter(MyBatisConfiger.class)
public class MapperScannerConfig {	
    @Bean
    public MapperScannerConfigurer mapperScannerConfigurer() {
        MapperScannerConfigurer mapper = new MapperScannerConfigurer();
        mapper.setBasePackage("com.cssl.dao");
        return mapper;
    }
}

或者直接使用注解扫描dao接口产生代理:

@MapperScan(basePackages="com.example.dao")

事务管理：在Spring Boot中推荐使用注解来声明事务 @EnableTransactionManagement @Transactional

首先需要导入依赖：

<dependency>
	<groupId>org.springframework.boot</groupId>
	<artifactId>spring-boot-starter-jdbc</artifactId>
</dependency>

当引入jdbc依赖之后，SpringBoot会自动默认分别注入DataSourceTransactionManager或JpaTransactionManager，所以我们不需要任何额外配置就可以用@Transactional注解进行事务的使用

第二种：使用mybatis官方提供的Spring Boot整合包实现

导入依赖 (自动导入mybatis、mybatis-spring、spring-jdbc、spring-tx等包) (自动读取数据库配置产生DataSource(HikariDataSource)、SqlSessionFactory及事务管理类)

<!-- 3.x需要匹配springboot3.x,2.x报找不到工厂 -->
<!-- 3.2.1需要匹配springboot3.0.3,否则工厂报类型失败 -->
<dependency>
      <groupId>org.mybatis.spring.boot</groupId>
      <artifactId>mybatis-spring-boot-starter</artifactId>
      <version>2.3.1</version> 
</dependency>

#yml:
spring:
  datasource:
    driver-class-name: com.mysql.cj.jdbc.Driver
    url: jdbc:mysql:///test?serverTimezone=Asia/Shanghai
    username: root
    password: root
  mvc:
    view:
      prefix: /
      suffix: .jsp
    
mybatis:
  config-location: classpath:mybatis-config.xml
#或者:
mybatis:
  type-aliases-package: com.cssl.pojo
  #这个不写有个警告可以不理他，写了后面打jar包反而启动报错
  #mapper-locations: classpath:/mapper/** 
  configuration:
    auto-mapping-behavior: full
    use-generated-keys: true
    log-impl: org.apache.ibatis.logging.stdout.StdOutImpl
    #log-impl: org.apache.ibatis.logging.log4j.Log4jImpl  #这个不打印查询结果

DAO接口产生代理只需要扫描:@MapperScan(basePackages="com.cssl.dao") 或者在dao接口上使用@Mapper

注意： 新版本2.1+默认使用数据库驱动8.0+ 1、driver：com.mysql.cj.jdbc.Driver 2、url要加时区：jdbc:mysql:///mydb?serverTimezone=Asia/Shanghai

阿里数据源：

<dependency>
    <groupId>com.alibaba</groupId>
    <artifactId>druid</artifactId>
    <version>1.2.15</version>
</dependency>

yml: type: com.alibaba.druid.pool.DruidDataSource

---

四、分页插件PageHelper：

方式一：使用原生的PageHelper

<dependency>
	<groupId>com.github.pagehelper</groupId>
	<artifactId>pagehelper</artifactId>
	<version>[6.0.0,)</version>
</dependency>

Java配置代码:

@Bean
public PageInterceptor pageInterceptor(SqlSessionFactoryBean factory){
    //分页插件5.x
    Properties properties = new Properties();
    properties.setProperty("reasonable", "true");
    properties.setProperty("pageSizeZero", "true");

    PageInterceptor interceptor = new PageInterceptor();
    interceptor.setProperties(properties);
    //添加插件
    factory.setPlugins(new Interceptor[]{interceptor});
    return interceptor;
}

方式二：使用PageHelper的starter(PageHelper5.3.x)

<dependency>
	<groupId>com.github.pagehelper</groupId>
	<artifactId>pagehelper-spring-boot-starter</artifactId>
	<version>[2.0.0,)</version>	
</dependency>

pagehelper分页插件配置(不是必须)

pagehelper: 
  reasonable: true
  page-size-zero: true

注意：手动加@ComponentScan(basePackages = "com.cssl")扫描破坏过滤造成分页不起作用，要excludeFilters

@ComponentScan(basePackages = "com.cssl",excludeFilters = { 
@Filter(type = FilterType.CUSTOM, classes = TypeExcludeFilter.class),
@Filter(type = FilterType.CUSTOM, classes = AutoConfigurationExcludeFilter.class)})

---

五、其他配置类：

org.springframework.boot.autoconfigure.web.WebMvcConfigurer

1、Spring Boot添加MVC配置：

实现接口WebMvcConfigurer

@Component
public class MyMvcConfig implements WebMvcConfigurer {
       
	@Override
	public void addInterceptors(InterceptorRegistry registry) {
		System.out.println("添加自己定义拦截器");
        
		registry.addInterceptor(new MyIntercepter())
            .addPathPatterns("/**")
            .excludePathPatterns("/js/**", "/images/**");
        
        registry.addInterceptor(new AuthorityInterceptor())
			.addPathPatterns("/**")
			.excludePathPatterns("/images/**")
			.excludePathPatterns("/js/**");
	}
    
    /**
     * 以前要访问一个页面需要先创建个Controller控制类，再写方法跳转到页面
     * 在这里配置后就不需要那么麻烦了，直接访问toLogin就跳转到login.jsp页面了 
     */
    @Override
    public void addViewControllers(ViewControllerRegistry registry){
        registry.addViewController("/toLogin").setViewName("login");
    }

    @Override
    public void configureViewResolvers(ViewResolverRegistry registry) {
        //注册BeanNameViewResolver？
    	//registry.jsp("/WEB-INF/jsp/", ".jsp");    
    	registry.viewResolver(new InternalResourceViewResolver("/", ".jsp"));
    }

    @Override
    public void configureMessageConverters(List<HttpMessageConverter<?>> converters) {
    	StringHttpMessageConverter sh = new StringHttpMessageConverter(Charset.forName	("utf-8"));
    	//没有添加默认也有该消息转换器
    	converters.add(sh);
    }

	@Override
	public void addCorsMappings(CorsRegistry registry) {
    	// 设置允许跨域的路由
    	registry.addMapping("/**")           
            .allowedOriginPatterns("*") // 设置允许跨域请求的域名
            .allowCredentials(true)// 是否允许证书（cookies）           
            .allowedMethods("*")// 设置允许的方法           
            .maxAge(3600);// 跨域允许时间
	}
}

2、SpringBoot使用监听器|过滤器|Servlet：

@ServletComponentScan("com.cssl.web")

Web(过滤器|监听器)获取当前的Spring IoC容器 方法一：（通过ServletContext加载spring容器，SpringBoot适用） ApplicationContext c=WebApplicationContextUtils.getWebApplicationContext(application);

方法二：（获取当前的spring容器，普通java类也适用，SpringBoot不适用，SpringBoot可以@Autowire直接注入ioc容器中的对象，不需要再获取容器） WebApplicationContext c=ContextLoader.getCurrentWebApplicationContext();

3、MVC异常处理：(和SpringMVC一样)

a、Advice异常处理

@ControllerAdvice
public class ExceptionHandlerAdvice {

	@ExceptionHandler(Exception.class)
	public String handleException(Exception e) { ... }
    
    @ModelAttribute ...
    public UsersVo getModel(){ ... }
}

b、父级Controller异常处理 定义父类 BaseController：

public class BaseController {

	@ExceptionHandler(Exception.class)
	public String handleException(Exception e) { ... }
}

4、自动启动

在开发中可能会需要在容器启动的时候执行一些操作。比如读取配置文件或读取数据库数据注入redis。SpringBoot给我们提供了两个接口来帮助我们实现这种需求。这两个接口分别为CommandLineRunner和ApplicationRunner。他们的执行时机为容器启动完成的时候。

5、上传文件

大小的限制是1MB，超过出现错误(springboot3不报异常就是不上传)：org.springframework.web.multipart.MultipartException。 设置application.yml:

spring:
  servlet:
    multipart:
      enabled: true 			#是否启用http上传处理
      max-request-size: 100MB 	#最大请求文件的大小
      max-file-size: 20MB 		#设置单个文件最大长度
      file-size-threshold: 20MB #当文件达到多少时进行磁盘写入

或者:

@Configuration
public class UploadConfig {
    @Bean
    public MultipartConfigElement multipartConfigElement() {
        MultipartConfigFactory factory = new MultipartConfigFactory();
        // 单个文件最大
        factory.setMaxFileSize("20480KB"); //KB,MB
        // 设置总上传数据总大小
        factory.setMaxRequestSize("1024000KB");
        return factory.createMultipartConfig();
    }
}

如果使用了nginx则要修改配置文件nginx.conf

6、SpringBoot默认日志:logback(@Slf4j)

logback-spring.xml:

<?xml version="1.0" encoding="UTF-8" ?>
<configuration>
    <!-- 控制台显示 -->
    <appender name="console" class="ch.qos.logback.core.ConsoleAppender">
        <layout>
            <pattern>[%p]%d-%msg%n</pattern>
        </layout>
    </appender>
   
    <!-- 按天和大小显示 -->
    <appender name="ROLLING" class="ch.qos.logback.core.rolling.RollingFileAppender">       
        <rollingPolicy class="ch.qos.logback.core.rolling.SizeAndTimeBasedRollingPolicy">
            <!-- rollover daily -->
            <fileNamePattern>maven/mylog-%d{yyyy-MM-dd}.%i.txt</fileNamePattern>         
            <maxFileSize>100KB</maxFileSize>
            <maxHistory>60</maxHistory>
            <totalSizeCap>20GB</totalSizeCap>
        </rollingPolicy>
        <encoder>
            <pattern>%msg%n</pattern>
        </encoder>
    </appender>
    
    <root level="error">
        <appender-ref ref="console" />
        <appender-ref ref="ROLLING" />
    </root>
</configuration>

---

六、配置文件加密

SpringBoot资源文件中的内容通常情况下是明文显示，安全性比较低。打开application.properties或application.yml，mysql登陆密码，以及第三方的密钥等一览无余，这里介绍一个加解密组件，提高属性配置的安全性。 　　jasypt是由一个国外大神写的一个springboot下的工具包。

1、引入依赖

<dependency>
	<groupId>com.github.ulisesbocchio</groupId>
	<artifactId>jasypt-spring-boot-starter</artifactId>
	<version>2.0.0</version>	
</dependency>

如果用2.1.0必须导全三个(没有传递依赖)

<dependency>
	<groupId>com.github.ulisesbocchio</groupId>
	<artifactId>jasypt-spring-boot-starter</artifactId>
	<version>2.1.0</version>	
</dependency>

<dependency>
	<groupId>com.github.ulisesbocchio</groupId>
	<artifactId>jasypt-spring-boot</artifactId>
	<version>2.1.0</version>
</dependency>
	
<dependency>
	<groupId>org.jasypt</groupId>
	<artifactId>jasypt</artifactId>
	<version>1.9.3</version>
</dependency>

springboot3需要3.x:

<dependency>
	<groupId>com.github.ulisesbocchio</groupId>
	<artifactId>jasypt-spring-boot-starter</artifactId>
	<version>3.0.5</version>	
</dependency>

2、yml配置

#jasypt加密的密匙(盐值)
jasypt:
  encryptor:
    password: EbfYkitulv73I2

也可以在JVM启动参数中设置保证安全：

java -jar -Djasypt.encryptor.password=EbfYkitulv73I2 demo.jar

Eclipse:

【Run As】-->【Run Configurations】

长久性修改JVM启动内存：【Window】-->【Preferences】-->【Java】-->【Installed JREs】-->双击JRE-->找到【Default VM arguments】，输入“-Xms128m -Xmx512m”

3、在测试用例中生成秘钥

<dependency>
	<groupId>org.springframework.boot</groupId>
	<artifactId>spring-boot-starter-test</artifactId>
	<scope>test</scope>
</dependency>

@SpringBootTest
public class JTest {
    @Autowired
    StringEncryptor encryptor;

    @Test
    public void encrypt() {
        String url = encryptor.encrypt("jdbc:mysql:///mydb2?serverTimezone=GMT");
        String name = encryptor.encrypt("你的数据库用户名");
        String password = encryptor.encrypt("你的数据库密码");
        System.out.println(url);
        System.out.println(name);
        System.out.println(password);
    }
    
    @Test
    public void decrypt() {
        String url = encryptor.decrypt("VAPRunIXQQLqKAr2ZaT+v95SiiuYGQxRM0PV2031dCKX0egG1LMWlaCzdRjTQ4Vq");
        String name = encryptor.decrypt("C7pFSukKhLgPTKJuTe6QNQ==");
        String password = encryptor.decrypt("XQZ5KT8yPapb9TMYrrZSJg==");
        System.out.println(url);
        System.out.println(name);
        System.out.println(password);
    }
}

地址：cKsB8iGrXlNtX7+L/ldzl8a6Mn3BH4XYDiqmbdvSd5vRTFblpShF6lT0yk70bY7INfi0pKgH+yB9Vyg==
姓名：03ybwYLnC8Cj88GSoeCIAg==
密码：q45psKASQHwKAaRrqjroZA==

4、配置

将上面生成的name和password替换配置文件中的数据库账户和密码，替换后如下：

spring:
  #数据库相关配置
  datasource:
    driver-class-name: com.mysql.jdbc.Driver    
    url: ENC(GBQBRUVmTEqu/zpH33M639Kj0IqXVDMoWahGp70z9vPHH3eASU3ZoFff/80gfZwC)
    username: ENC(1JLSxqte89sAZs9El1u0Pg==)
    password: ENC(otVXGXBVUrebggKOgEKQpA==)

---

七、IDEA工具的使用

注意：

1. maven项目中，手动创建的webapp目录不能访问，要使用webapp骨架或者手动添加Web资源目录

2. 如果手动添加了Web资源还不行，设置Working directory

   老版本：Edit Configurations->Configuration->Environment（右边+选$MODULE_DIR$）

   新版本：Edit Configurations->Modify options->Working directory选$MODULE_DIR$

3. IDEA的maven项目中，默认源代码(src/main/java)目录下的xml等资源文件并不会在编译的时候一块打包进classes文件夹，而是直接舍弃掉(Eclipse打war包也会丢弃java目录下的xml)

4. 解决这个问题有两种方式： 第一种是在src/main/resources下建立目录，将xml等资源文件放置到这个目录中。maven工具默认在编译的时候，会将resources文件夹中的资源文件一块打包进classes目录中。

第二种解决方式是配置maven的pom文件配置，在pom文件中找到<build>节点，添加下列代码：

<build>
    <resources>
        <resource>
            <directory>src/main/java</directory>
            <includes>
                <include>**/*.properties</include>
                <include>**/*.xml</include>
            </includes>
            <filtering>false</filtering>
        </resource>
        <!-- 最好加上，避免后面打war包出错 -->
        <resource>
            <directory>src/main/resources</directory>
            <includes>
                <include>**/*.*</include>				
            </includes>
            <filtering>false</filtering>
        </resource>
    </resources>
</build>

---

八、SpringBoot项目发布到独立的tomcat中运行：

(注意jdk环境：编译版本和运行版本还有maven的JDK版本一致)

<properties>
	<java.version>15</java.version>   
</properties>

在开发阶段我们推荐使用内嵌的tomcat进行开发，因为这样会方便很多，但是到测试和生产环境，希望在独立的tomcat容器中运行，因为我们需要对tomcat做额外的优化，这时我们需要将工程打成war包发布。

1. 工程的打包方式为war

<packaging>war</packaging>

1. 如果添加了servlet|jsp依赖，注意<scope>provided</scope>

<dependency>
      <groupId>org.apache.tomcat.embed</groupId>
      <artifactId>tomcat-embed-jasper</artifactId>
      <scope>provided</scope>
</dependency> 

1. 将spring-boot-starter-tomcat的范围设置为provided（spring-boot-starter-web自带Tomcat） 设置为provided是在打包时会将该包排除，因为要放到独立的tomcat中运行，是不需要的

<dependency>
	<groupId>org.springframework.boot</groupId>
	<artifactId>spring-boot-starter-tomcat</artifactId>
	<scope>provided</scope>
</dependency>

<!--也可以在导入spring-boot-starter-web时配置移除嵌入式tomcat插件 -->
<dependency>
	<groupId>org.springframework.boot</groupId>
	<artifactId>spring-boot-starter-web</artifactId>	
	<exclusions>
		<exclusion>
			<groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-tomcat</artifactId>
        </exclusion>
	</exclusions>
</dependency>

1. 修改编译设置

<build>
	<plugins>
    	<plugin>
            <groupId>org.apache.maven.plugins</groupId>
            <artifactId>maven-war-plugin</artifactId>
            <version>3.2.3</version>
        </plugin>
        <plugin>
            <groupId>org.apache.maven.plugins</groupId>
            <artifactId>maven-compiler-plugin</artifactId>
            <version>3.8.1</version>                
        </plugin>
	</plugins>
    <!--  一般和项目名相同，打包成demo.war -->
	<finalName>demo</finalName>
</build>

1. 修改代码，设置启动配置 需要集成SpringBootServletInitializer，然后重写configure，将SpringBoot的入口类设置进去。

//注意：SpringBoot1.x和2.x的包路径不同
@SpringBootApplication
public class MywarApplication extends SpringBootServletInitializer {

    @Override
    protected SpringApplicationBuilder configure(SpringApplicationBuilder builder) {
        return builder.sources(MywarApplication.class);
    }
}

1. 打war包 Eclipse:工程右键->Run As->Maven build (Goals输入：clean package)

   IDEA: 1、Edit Configurations->“+”->maven->directory|Command line(clean package) 2、在Maven视图Lifecycle右键运行或双击运行 3、也可以直接jsp右键运行会自动打war包

   4、命令行：mvn package

2. 将war包复制到webapps下，启动

3. 部署到服务器注意JDK版本和Tomcat版本匹配，否则容易404(MySQL驱动异常)，

   （可以部署到本地Tomcat测试后再上传到服务器）

其他：

1. properties<->yml： 在线properties转yaml-在线yaml转properties-ToYaml.com

2. Idea新建项目maven仓库还原默认的解决： File->Other Settings->Default Settings | Settings for NewProject(2019+) 将Maven home directory目录修改成我们自定义安装Maven的目录

3. SpringBoot在IDEA下热部署不起作用（见SpringBoot_IDEA热部署.docx）

4. 打jar包使用 java -jar运行

<build>
	<plugins>
        <plugin>
            <groupId>org.apache.maven.plugins</groupId>
            <artifactId>maven-compiler-plugin</artifactId>
            <version>3.8.1</version>
            <configuration> <!-- 保持JDK版本一致 -->
                <source>17</source>
                <target>17</target>
            </configuration>
        </plugin>
		<!-- 解决SpringBoot打包成jar不包含依赖，运行没有主清单属性问题 -->
		<plugin>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-maven-plugin</artifactId>
            <version>1.4.2.RELEASE</version>           
            <configuration>
                <mainClass>com.cssl.DemoApplication</mainClass>
            </configuration>		
            <executions>
                <execution>
                    <goals>
                        <goal>repackage</goal>
                    </goals>
                </execution>
            </executions>
        	
        </plugin>	    
    </plugins>
    <resources> 
        <resource>
            <!-- JSP包打包到资源里 -->
            <directory>${basedir}/src/main/webapp</directory>
            <!-- 指定resources插件处理哪个目录下的资源文件 -->
            <targetPath>META-INF/resources</targetPath>
            <includes>
                <include>**/**</include>
            </includes>
        </resource>
    </resources>
</build>

1. 注意：

   a、打包运行出现找不到模板的500异常一般是控制器返回字符串带有 '/' 或者th:include包含 '/'，

   b、springboot 打包插件如果要支持JSP版本必须为1.4.2.RELEASE，只有这个版本支持jsp，高版本不行 c、webapp下所有的前端资源必须打包到jar包的META-INF/resources的目录下，否则无法识别

   d、命令行参数优先级更高java -jar xxx.jar --server.port=8888 或者直接指定位置文件启动 java -jar xxx.jar --spring.config.location=d:/xx.yml

2. IDEA Springboot项目application.yml文件不能识别并自动补全提示：

   目前application.yml显示的是普通file格式，没能识别spring的yml格式，也不会自动补全配置代码。

   解决：files-----settings-------editor------file types

   在上面一栏选中YAML，然后再在下面一栏中添加.yaml和.yml。

   重启idea即可。

3. IDEA Springboot项目application.properties文件不能识别：

由于什么误操作将这个application.properties文件标记为text文件了...才导致了问题。

Eclipse不能识别一般是插件问题，重新安装SpringTools 4.x插件。

8、Springboot项目中使用@Autowired注解时，出现红色波浪线报错问题解决

解决办法一：降低IDEA对代码的审查级别

操作步骤：把鼠标放到出错的代码上，过几秒左侧会出现一个小灯泡（如果不出现其实也可以按 Alt+ Enter，就会出现提示了，这种方式更好），点击灯泡，然后如图所示：

解决办法二：添加注解，注入相应的类

解决办法三：将@Autowired替换成@Resource就可以了。