Spring Boot学习笔记

Spring Boot 学习笔记

Spring Boot引言

Spring Boot由Pivotal团队提供，目的是简化Spring应用的初始搭建以及开发过程，是一个微框架，一个约定大于配置的框架。

springboot(微框架) = springmvc(控制器) + spring(项目管理)

Spring Boot 特点

1. 创建独立的Spring应用程序
2. 嵌入Tomcat，无需部署WAR文件
3. 简化Maven配置
4. 自动配置Spring
5. 没有XML配置

Spring Boot第一个环境搭建

1. 创建Maven的web项目，引入springboot的jar包

   <!--  继承springboot的父项目  -->
   <parent>
   	<groupId>org.springframework.boot</groupId>
   	<artifactId>spring-boot-starter-parent</artifactId>
   	<version>1.5.7.RELEASE</version>
   </parent>
   	
   <dependencies>
   	<dependency>
   		<groupId>junit</groupId>
   		<artifactId>junit</artifactId>
   		<version>4.12</version>
   		<scope>test</scope>
       </dependency>
   
       <!--  添加springboot web项目支持  -->
       <dependency>
       	<groupId>org.springframework.boot</groupId>
       	<artifactId>spring-boot-starter-web</artifactId>
      	</dependency>
   	<!-- 测试 -->
       <dependency>
         <groupId>org.springframework.boot</groupId>
         <artifactId>spring-boot-starter-test</artifactId>
         <!-- 只在test测试里面运行 -->
         <scope>test</scope>
       </dependency>
   </dependencies>
   

2. springboot的配置文件

  server:
    port: 8585   #代表当前应用的端口号
    context-path: /springboot   #代表访问时的项目名(必须有“/”,否则报错)

注：

1. springboot的配置文件必须在根目录下，如：放在maven项目下的main目录下的resources目录下。

2. springboot的配置文件名称必须为 application.yml 或者 application.properties

3. 编写springboot入口类

包结构:
项目名
	src
		main
			java
				com.baizhi
					controller
					dao
					entity
		 			(入口类)Application.java
			resources
			webapp
		test
			java
			resources
				

注：

1. springboot的每个项目有且只有一个入口类
2. springboot的入口类必须放在springboot项目下的所有子包之上。即：入口类与所有子包处于同一目录级别。

​ 3. 入口类的名字建议为：Application.java

/**
 * 用來修饰类，
 * 标识这个项目是一个springboot项目入口类
 * 这个注解只能出现一次
 * 只能加在入口类中
 */
@SpringBootApplication
public class Application {
    public static void main(String[] args) {
        SpringApplication.run(Application.class,args);
    }
}

注：

1. 入口类中有一个main方法, 在main方法中使用**SpringApplication.run(xxxApplication.class,args)**启动 springboot应用的项目。
2. run方法中的参数xxxApplication.class为入口类的类名，args为main方法的参数。
3. 入口类上的注解==@SpringBootApplication== = @Configuration + @EnableAutoConfiguration + @ComponentScan 组成。

​ — @Configuration 注解对springboot应用初始化的自动配置

​ — @EnableAutoConfiguration 注解对在springboot应用中引入第三方jar做自动配置

​ — @ComponentScan 注解用来组件扫描 用来扫描入口类下所有组件上的相关注解

4. 创建控制器

spring控制器开发(@Controller + @ResponseBody)：

@Controller
@RequestMapping("/hello")
public class HelloController {

    @RequestMapping("/hello")
    @ResponseBody
    public String hello() {
        System.out.println("springBoot hello world!");
        return "ok";
    }
}

注：
可以使用注解==@RestController== = @Controller + @ResponseBody 组成。
​ 修饰范围： 可以加在类上。
​ 作用： 标识这个类是一个控制器类，又代表这个类中所有的控制器方法的返回值为JSON格式的数据。如若控制器的方法既有JSON串又有jsp页面跳转，则仍需要使用原始的@Controller+@ResponseBody注解。

注: 这个注解底层默认使用Jackson。

springboot控制器开发(@RestController)：

@RestController
@RequestMapping("/hello")
public class HelloController {

    @RequestMapping("/hello")
    public String hello() {
        System.out.println("springBoot hello world!");
        return "ok";
    }
}

Spring Boot项目的快速搭建

Idea提供了springboot项目的快速搭建功能，步骤如下图所示：

注：

1. springboot项目的快速创建需要连接网络。
2. springboot创建完成后，步骤8创建时选择的继承springboot的父项目版本为2.1.1可能会出现问题，如果产生问题的话，可以在项目的pom.xml文件中将继承的父项目版本号修改为1.5.x尝试一下,如下图：
   

可以通过maven命令使用命令行快速创建：
https://maven.apache.org/archetype/maven-archetype-plugin/generate-mojo.html
参考视频：https://www.imooc.com/video/16355

使用命令行打包：
进入项目目录执行以下命令：
mvn -Dmaven.test.skip -U clean package

spring boot 访问页面

1. 如果没有配置springboot的application.properties配置文件
   访问方式为：ip:8080/+直接对应的项目中resources文件中的static包下的文件路径
2. 如果配置了springboot的application.properties配置文件，如下：

   server.port=8585
   server.servlet.context-path=/layui
   

   则你的访问方式为：ip:8585/layui/+直接对应的项目中resources文件中的static包下的文件路径
3. 另外当你的页面放置在templates文件夹下时，必须通过controller进行跳转访问

Spring Boot 启动原理

收集各种条件和回调函数，如:各类监听器和初始化组件，准备好之后告知spring可以开始构建spring环境，当环境构建完毕后，告知spring可以开始创建spring工厂，初始化完成spring
工厂后，设置环境，将二者联系在一起，spring工厂初始化完毕， 通过@EnableConfiguration中的EnableAutoConfigurationImportSelector从父类
AutoConfigurationImportSelector继承到的方法selectImports(实现的ImportSelector的方法)找到需要加载的第三方jar全类名（spring.factories中的全类名），使用SpringFactoriesLoader
通过反射创建出Bean对象的实例（即配置类实例）；通过将所有的@Configuration中的标记
的配置类对象中的所有被@Bean标记的实例,放置于工厂当中（配合使用了
@ComponentScan进行扫描），每次将bean对象放置于spring工厂时会调用refresh方法刷新工厂，当所有的Bean对象完成放置后，调用finished方法完成spring工厂的创建，启动
springboot程序。

1. IDEA方式运行
2. JAR/WAR方式运行
3. Maven 插件方式运行

   在项目目录下执行命令：
   mvn -Dmaven.test.skip -U clean install
   mvn spring-boot:run

Spring Boot的启动标志图

示意图：

在根目录下创建banner.txt文件，然后浏览器打开网址：http://www.network-science.de/ascii/ 或 http://patorjk.com/software/taag 生成静态字符图，然后将生成的字符图复制粘贴到banner.txt文件中即可。

Spring Boot 配置文件拆分

springboot的配置文件appliaction.yml 或 application.properties可以依需求进行拆分为application-dev.yml 和 application-prod.yml。

拆分后的application.yml

spring:
  profiles:
    active: prod   #指定应用的项目名称    ， 注意关键词与值之间的 空格

注： 以上三行代码的缩进是必须的，否则程序无法访问。

拆分成的application-dev.yml

server:
  port: 8585  #代表当前应用的端口号    ， 注意关键词与值之间的 空格
  context-path: /springboot #代表访问时的项目名（必须有"/"，否则报错）  ， 注意关键词与值之间的 空格

注： 以上三行代码的缩进是必须的，否则程序无法访问。

拆分成的application-prod.yml

server:
  port: 8586  #代表当前应用的端口号 ， 注意关键词与值之间的 空格
  context-path: /springboot1 #代表访问时的项目名（必须有"/"，否则报错） ， 注意关键词与值之间的 空格

注： 以上三行代码的缩进是必须的，否则程序无法访问。

注：

1. 拆分后的两个文件application-dev.yml 与 application-prod.yml 之中的port不能相同，context-path也不能相同。
2. application-xxx.yml 中的xxx是自定义的。

Spring Boot 的日志管理

springboot 默认集成了logback，所以使用的日志展示不在是log4j，而是logback日志展示。logback 相较于log4j更加轻量化。

1. springboot项目日志只需要在项目的根路径下放置一个名字为 logback.xml 配置文件即可 。如下图：
   
2. 配置logback.xml文件：

<configuration>
    <appender name="stdout" class="ch.qos.logback.core.ConsoleAppender">
        <layout class="ch.qos.logback.classic.PatternLayout">
            <pattern> [%p] %d{yyyy-MM-dd HH:mm:ss} %m %npattern>
        layout>
    appender>
    <root level="ERROR">
        <appender-ref ref="stdout"/>
    root>
    <logger name="com.baizhi.dao" level="DEBUG"/>
configuration>

注： 日志的级别优先级从高到低依次为：OFF、FATAL、ERROR、WARN、INFO、DEBUG、TRACE、 ALL。

ALL  最低等级的，用于打开所有日志记录。

TRACE designates finer-grained informational events than the DEBUG.Since:1.2.12，很低的日志级别，一般不会使用。

DEBUG 指出细粒度信息事件对调试应用程序是非常有帮助的，主要用于开发过程中打印一些运行信息。

INFO 消息在粗粒度级别上突出强调应用程序的运行过程。打印一些你感兴趣的或者重要的信息，这个可以用于生产环境中输出程序运行的一些重要信息，但是不能滥用，避免打印过多的日志。

WARN 表明会出现潜在错误的情形，有些信息不是错误信息，但是也要给程序员的一些提示。

ERROR 指出虽然发生错误事件，但仍然不影响系统的继续运行。打印错误和异常信息，如果不想输出太多的日志，可以使用这个级别。

FATAL 指出每个严重的错误事件将会导致应用程序的退出。这个级别比较高了。重大错误，这种级别你可以直接停止程序了。

OFF 最高等级的，用于关闭所有日志记录。
--------------------- 
作者：小东升职记 
来源：CSDN 
原文：https://blog.csdn.net/qq_38704184/article/details/82318207 
版权声明：本文为博主原创文章，转载请附上博文链接！

一般推荐的日志级别：

项目日志   WARN
子日志	    DEBUG

Spring Boot 中的细节问题

1. 中文乱码

   解决方式：在application.yml文件中配置编码格式

   spring:
     http:
       encoding:
         charset: UTF-8
         force: true
   

   源码

   @ConfigurationProperties(
       prefix = "spring.http.encoding"
   )
   public class HttpEncodingProperties {
       public static final Charset DEFAULT_CHARSET = Charset.forName("UTF-8");
       private Charset charset;
       private Boolean force;
       private Boolean forceRequest;
       private Boolean forceResponse;
       private Map<Locale, Charset> mapping;
       ...
   

2. 文件上传

   解决方式： 在application.yml文件中配置文件大小

   spring:
     http:
       multipart:
         max-file-size: 20MB
         max-request-size: 50MB
   

   源码

   @ConfigurationProperties(
       prefix = "spring.http.multipart",
       ignoreUnknownFields = false
   )
   public class MultipartProperties {
       private boolean enabled = true;
       private String location;
       private String maxFileSize = "1MB";   //文件上传大小
       private String maxRequestSize = "10MB";  //一次请求上传大小
       private String fileSizeThreshold = "0";
       private boolean resolveLazily = false;
   

3. 日期格式

   解决方式1：在实体类中的日期属性上加@JsonFormat注解

   @JsonFormat("yyyy-MM-dd hh:mm:ss")
   private Date date;
   

   解决方式2： 在application.yml 文件中配置日期格式

   spring:
     jackson:
      	date-format: yyyy-MM-dd HH:mm:ss
       time-zone: GMT-8
   

4. 静态资源的处理

   springboot中对静态资源不需要做处理

   springboot对于get请求 — 先找静态资源，在找控制器

   ​ 对于post请求 — 直接找控制器

5. 事务控制

   springboot中的事务控制是默认被开启的

Spring Boot 与 jsp 集成

1. 引入jsp集成依赖jar

配置pom.xml文件

    <dependency>
      <groupId>jstlgroupId>
      <artifactId>jstlartifactId>
      <version>1.2version>
    dependency>
    <dependency>
      <groupId>org.springframework.bootgroupId>
      <artifactId>spring-boot-starter-tomcatartifactId>
    dependency>
    <dependency>
      <groupId>org.apache.tomcat.embedgroupId>
      <artifactId>tomcat-embed-jasperartifactId>
    dependency>

2. 引入jsp运行插件

配置pom.xml文件

    <plugins>
      <plugin>
        <groupId>org.springframework.bootgroupId>
        <artifactId>spring-boot-maven-pluginartifactId>
      plugin>
    plugins>

注：

1. 引入jsp运行插件时，插件坐标必须放在标签之外，标签之内。

2. 为了springboot支持jsp模板不能使用 本地main函数启动，而是使用springboot：run启动。如图：
   
   ​ 原因：因为只有通过springboot启动，才会真正的调用springboot内嵌的Tomcat，而通过本地main函 数仅仅是监听了一个端口。

3. 修改springboot默认的模板引擎

   在springboot中有默认的试图解析器（模板引擎），使用的技术为 thymeleaf 后缀是.html 即为页面静态化技术，但也可以动态渲染后台数据。

   注： 如果项目要使用jsp模板，必须修改springboot默认的模板引擎，配置application.yml

   spring:
     mvc:
       view:
         prefix: /   #注意关键词与值之间的 空格
         suffix: .jsp  #注意关键词与值之间的 空格
   

   springboot试图解析器 自动配置 之 源码

     	@Bean
   	@ConditionalOnMissingBean
   	public InternalResourceViewResolver defaultViewResolver() {
   		InternalResourceViewResolver resolver = new InternalResourceViewResolver();
   		resolver.setPrefix(this.mvcProperties.getView().getPrefix());
            resolver.setSuffix(this.mvcProperties.getView().getSuffix());
            return resolver;
       }
   

4. 设置jsp页面的热部署功能

   由于springboot内嵌的Tomcat不支持jsp的热部署，所以需要在application.yml中进行如下配置:

   server:
     jsp-servlet:
       init-parameters:
         development: true  #注意关键词与值之间的 空格
   

Spring Boot 与 MyBatis 的集成

1. 导入jar包：pom.xml文件中配置

       
       
         org.mybatis.spring.boot
         mybatis-spring-boot-starter
         1.0.0
       
       
       
         com.alibaba
         druid
         1.0.19
       
       
       
         mysql
         mysql-connector-java
         5.1.38
       
       
       
         org.mybatis
         mybatis
         3.2.8
       
   

2. 配置数据源参数 ：application.yml文件中配置

   spring：
     datasource:
       type: com.alibaba.druid.pool.DruidDataSource
       driver-class-name: com.mysql.jdbc.Driver
       url: jdbc:mysql://localhost:3306/test
       username: root
       password: root
   

3. 配置mapper文件位置及实体类别名：application.yml文件中配置

   mybatis:
     mapper-locations: classpath:com/baizhi/mapper/*Mapper.xml    #mapper文件位置配置
     type-aliases-package: com.baizhi.entity  #别名配置
   

4. 配置扫描dao位置

   dao位置扫描必须在入口类Application.java上加**@MapperScan(basePackages = “com.xxx.dao”)**注解。

   /**
    * 用來修饰类，
    * 标识这个项目是一个springboot项目入口类
    * 这个注解只能出现一次
    * 只能加在入口类中
    */
   @SpringBootApplication
   @MapperScan(basePackages = "com.xxx.dao")
   public class Application {
       public static void main(String[] args) {
           SpringApplication.run(Application.class,args);
       }
   }
   

Spring Boot 与 FastJSON 集成

1. 导入jar

   
       <dependency>
         <groupId>com.alibabagroupId>
         <artifactId>fastjsonartifactId>
         <version>1.2.42version>
       dependency>
   

   2.编写FastJson配置类

   package com.xxx.config;
   
   import com.alibaba.fastjson.serializer.SerializerFeature;
   import com.alibaba.fastjson.support.config.FastJsonConfig;
   import com.alibaba.fastjson.support.spring.FastJsonHttpMessageConverter;
   import org.springframework.boot.autoconfigure.web.HttpMessageConverters;
   import org.springframework.context.annotation.Bean;
   import org.springframework.context.annotation.Configuration;
   import org.springframework.http.MediaType;
   
   import java.util.ArrayList;
   import java.util.List;
   
   @Configuration  //注解该类为配置类,springboot启动时自动注解
   public class FastJSONConfig {
       //用来生成FastJsonHttpMessageConverter
       @Bean  //将方法的返回值作为spring工厂的对象进行管理
       public HttpMessageConverters getFastJsonHttpMessageConverter(){
   
           //定义一个转换消息的对象
           FastJsonHttpMessageConverter fastJsonHttpMessageConverter = 
               new FastJsonHttpMessageConverter();
           //创建fastjson的配置对象
           //添加fastjson的配置信息 比如 ：是否要格式化返回的json数据
           FastJsonConfig fastJsonConfig = new FastJsonConfig();
           //漂亮的打印json格式
           fastJsonConfig.setSerializerFeatures(SerializerFeature.PrettyFormat);
   
           //处理中文乱码
           List<MediaType> fastMediaType = new ArrayList<MediaType>();
           fastMediaType.add(MediaType.APPLICATION_JSON_UTF8);
           //修改相应类型
           fastJsonHttpMessageConverter.setSupportedMediaTypes(fastMediaType);
   
           //在转换器中添加配置信息
           fastJsonHttpMessageConverter.setFastJsonConfig(fastJsonConfig);
   
   
           return new HttpMessageConverters(fastJsonHttpMessageConverter);
       }
   }
   

Spring Boot 中的测试类

springboot的测试类上必需加 @RunWith(SpringRunner.class) 与 @SpringBootTest 注解

@RunWith(SpringRunner.class)
@SpringBootTest(classes = Application.class)//当测试类与入口类不同级时 需要手动指定入口类的类对象
public class TestDao {
    @Autowired
    private UserDao userDao;
    @Test//junit 版本需要在4.12及其以上
    public void test01(){
        List<User> users = userDao.queryAllUser();
        System.out.println(users);
    }
}

注：

1. 如果 入口类Application.java 与 测试类的子包 不在同一级，则必须添加注解 SpringBootTest(classes = Application.class)
2. springboot的测试类要求 junit必须是4.12版本及以上

Spring Boot 中的 lombok 技术

​ lombok使java代码变的更加优雅，以注解的方式代替之前的冗长代码，底层采用字节码技术生成相应方法。

1. 下载lombok相关插件，如下图：
   

2. 下载lombok相关jar

   
   
   <dependency>
   	<groupId>org.projectlombokgroupId>
   	<artifactId>lombokartifactId>
   	<version>1.18.4version>
   	<scope>providedscope>
   dependency>
   

3. 常用注解的解释

   @Data ：	注解在类上；提供类所有属性的 getting 和 setting 方法，此外还提供了toString、
   		equals、hashCode、canEqual 方法
   @Value ： 注解和@Data类似，区别在于它会把所有成员变量默认定义为private final修饰，并且不会
   		生成set方法。
   @Setter ： 注解在属性上；为属性提供 setting 方法
   @Getter ： 注解在属性上；为属性提供 getting 方法
   @NoArgsConstructor ： 注解在类上；为类提供一个无参的构造方法
   @AllArgsConstructor ： 注解在类上；为类提供一个全参的构造方法
   @NonNull ： 如果给参数加个这个注解 参数为 null 会抛出空指针异常
   @Log4j ： 注解在类上；为类提供一个 属性名为log 的 log4j 日志对象
   

注： 使用lombok插件中的注解去自动生成set/get等方法，不能再手动创建set/get等方法，否则会出现错误

Spring Boot 中使用 MBG（mybatis-generator）技术

​ MBG是mybatis的一个插件，根据创建数据库表，生成实体类、dao、mapper文件 。

1. 导入MBG相关依赖 jar

   >
   	<!-- MBG插件依赖核心jar -->
   	
   		org.mybatis.generator
   		mybatis-generator-core
   		1.3.2
   	
   	
   	
           >mysql>
           >mysql-connector-java>
       	>5.1.38>
       >
   >
   

2. 导入MBG相关插件

   
   	
   		org.mybatis.generator
   		mybatis-generator-maven-plugin
   		1.3.2
            
            	
               	mysql
               	mysql-connector-java
               	5.1.38
               
            
            
            	     
            	
            		${basedir}/src/main/resources/generatorConfig.xml
            	
             	true
            
   	
   
   

3. 配置generatorConfig.xml配置文件

   
   
   <generatorConfiguration>
       <context id="test" targetRuntime="MyBatis3">
           <plugin type="org.mybatis.generator.plugins.EqualsHashCodePlugin">plugin>  
           <plugin type="org.mybatis.generator.plugins.SerializablePlugin">plugin> 
           <plugin type="org.mybatis.generator.plugins.ToStringPlugin">plugin>
           <commentGenerator>
               
               
               <property name="suppressDate" value="true" />
               
               <property name="suppressAllComments" value="true" />
           commentGenerator>
           
           <jdbcConnection driverClass="com.mysql.jdbc.Driver"
               connectionURL="jdbc:mysql://localhost/test" userId="root" password="123456">
           jdbcConnection>
           <javaTypeResolver>
               
               <property name="forceBigDecimals" value="false" />
           javaTypeResolver>
           
           <javaModelGenerator targetPackage="com.baizhi.entity"
               targetProject="src/main/java">
               <property name="enableSubPackages" value="true" />
               <property name="trimStrings" value="true" />
           javaModelGenerator>
   
           
           <sqlMapGenerator targetPackage="mapper" targetProject="src/main/resources">
               <property name="enableSubPackages" value="true" />
           sqlMapGenerator>
   
           
           <javaClientGenerator type="XMLMAPPER"
               targetPackage="com.baizhi.dao" targetProject="src/main/java">
               <property name="enableSubPackages" value="true" />
           javaClientGenerator>
           
           
           <table tableName="album" domainObjectName="Album"
               enableCountByExample="false" enableUpdateByExample="false"
               enableDeleteByExample="false" enableSelectByExample="false"
               selectByExampleQueryId="false">table>
           <table tableName="user" domainObjectName="User"
               enableCountByExample="false" enableUpdateByExample="false"
               enableDeleteByExample="false" enableSelectByExample="false"
               selectByExampleQueryId="false">table>
       context>
   generatorConfiguration>
   

4. 运行mybatis-generator:generate
   

Spring Boot 中使用 通用Mapper 技术

​ 官网 : https://github.com/abel533/Mapper/wiki

​ 通用mapper和MBG对比

MBG	通用Mapper
反向生成实体、dao、mapper	通过实体帮你生成sql语句

1. 导入相关依赖jar

   <!--通用mapper的启动器 注意这是mybatis和mybatis启动器的封装-->
       
         tk.mybatis
         mapper-spring-boot-starter
         2.1.1
       
   <!-- 数据源依赖jar -->
       
         com.alibaba
         druid
         1.0.19
       
   <!-- mysql驱动jar -->
       
         mysql
         mysql-connector-java
         5.1.38
       
   <!-- Mybatis与Springboot集成需要的依赖 -->
       
         org.mybatis.spring.boot
         mybatis-spring-boot-starter
         1.0.0
       
   

2. 配置application.yml文件

   server:
     port: 8585
     context-path: /dangdang
   spring:
     datasource:
       type: com.alibaba.druid.pool.DruidDataSource
       driver-class-name: com.mysql.jdbc.Driver
       url: jdbc:mysql://localhost:3306/dangdang
       username: root
       password: root
   mybatis:
     type-aliases-package: com.xxx.entity
     #mapper-locations: classpath:mapper/*Mapper.xml  #多表联查时，需要另写mapper.xml文件
   

3. 配置springboot入口类上的包扫描@MapperScan

   注： 不要使用mybatis原生的注解而是采tk.mybatis.spring.annotation.MapperScan。

   import org.springframework.boot.SpringApplication;
   import org.springframework.boot.autoconfigure.SpringBootApplication;
   import tk.mybatis.spring.annotation.MapperScan;
   
   @SpringBootApplication
   @MapperScan(basePackages = "com.baizhi.dao")
   public class DangDangApplication {
       public static void main(String[] args) {
           SpringApplication.run(DangDangApplication.class,args);
       }
   }
   

4. 编写dao接口，继承Mapper接口

   import com.xxx.entity.Address;
   import tk.mybatis.mapper.common.Mapper;
   
   public interface AddressDAO extends Mapper<Address> {
   }
   

5. 通用Mapper的相关注解

   @Table //用在类上 声明数据库的表名
   @Id //用在属性上 声明当前属性为主键
   @Column(name ="username") //作用在属性上 用来指定数据库中的字段名称
   //注意:建议使用驼峰命名法 数据库中以下划线分割如 userage 实体类中要使用驼峰规则如 userAge
   //主键策略 两种形式分别是oracle 和 mysql
   //oracle
   @KeySql(sql = "select sm_user_seq.nextval from dual", order = ORDER.BEFORE)
   //mysql
   @KeySql(useGeneratedKeys = true)
   @Transient //用在属性上 作用声明当前属性不是数据库中的列
   // 分页 RowBounds rowBounds=new RowBounds(4,4); 第一个参数是起始下标 第二个参数是每页的条
   数
   
   

Spring Boot 中的AOP动态代理

spring 与 springboot中的aop开发流程对比：

springboot 支持spring中的注解式AOP配置,而且配置简单只需要几步即可 :

1. 导入springboot与aop集成jar包

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

2. AOP注解

   @Aspect 用来类上,代表这个类是一个切面
   @Before 用在方法上代表这个方法是一个前置通知方法
   @After  用在方法上代表这个方法是一个后置通知方法
   @Around 用在方法上代表这个方法是一个环绕的方法
   @Order(1) 用在类上，代表这个AOP类执行的优先级，数字越小，级别越高
   @Configuration 用在类上，代表这个类是一个配置类，由spring自动配置
   

3. 开发前置通知AOP

   @Aspect
   @Configuration
   public class BeforeAspect {
       @Before("execution(* com.xxx.demo.*.*(..))")
       public void before(JoinPoint joinPoint){
           System.out.println("目标方法执行之前执行");
       }
   }
   

4. 开发后置通知AOP

   @Aspect
   @Configuration
   public class AfterAspect {
       @After("execution(* com.xxx.demo.*.*(..))")
       public void after(JoinPoint joinPoint){
           System.out.println("目标方法执行之后执行");
       }
   }
   

5. 开发环绕通知AOP

   @Aspect
   @Configuration
   public class AroundAspect {
       @Around("execution(* com.xxx.demo.*.*(..))")
       public Object around(ProceedingJoinPoint proceedingJoinPoint) {
           System.out.println("目标方法执行之前执行");
           Object proceed = null;
           try {
                proceed = proceedingJoinPoint.proceed();//放行目标方法
           } catch (Throwable throwable) {
               throwable.printStackTrace();
           }
           System.out.println("目标方法执行之后执行");
           return proceed;
       }
   }
   

注： JoinPoint 与 ProceedingJoinPoint类的参数可以用于获取方法名、方法参数、目标对象 。

System.out.println("获取方法名："+joinPoint.getSignature().getName());
System.out.println("获取方法参数："+joinPoint.getArgs());  //获取的是一个数组
System.out.println("获取目标对象："+joinPoint.getTarget());
System.out.println("获取目标对象："+joinPoint.getThis());

Spring Boot 中的拦截器

spring 与 springboot 中拦截器开发对比：

1. 编写拦截器

@Component  //注释定义实例化，便于可以使用工厂管理
public class MyInterceptor implements HandlerInterceptor {
    //请求处理之前，即请求进入控制器前，进行调用
    @Override
    public boolean preHandle(HttpServletRequest httpServletRequest, HttpServletResponse httpServletResponse, Object o) throws Exception {
        //用户强制登录，共同的设置等代码
        System.out.println("=============1=============");
        return true;  //放行请求
    }
    //当前请求进行处理之后，也就是Controller 方法调用之后执行，但是它会在DispatcherServlet 进行视图返回渲染之前被调用
    @Override
    public void postHandle(HttpServletRequest httpServletRequest, HttpServletResponse httpServletResponse, Object o, ModelAndView modelAndView) throws Exception {
        System.out.println("=============2=============");
    }
    //在整个请求结束之后，也就是在DispatcherServlet 渲染了对应的视图之后执行。这个方法的主要作用是用于进行资源清理工作的
    @Override
    public void afterCompletion(HttpServletRequest httpServletRequest, HttpServletResponse httpServletResponse, Object o, Exception e) throws Exception {
        System.out.println("==============3=============");
    }
}

2. 编写拦截器配置类

@Configuration  //注释定义为配置类
public class MyInterceptorConfig extends WebMvcConfigurerAdapter {
    @Resource  //将之前编写的拦截器注入
    private MyInterceptor myInterceptor;
    //覆盖springboot中的默认拦截器方法
    public void addInterceptors(InterceptorRegistry registry) {
        registry.addInterceptor(myInterceptor)  //添加要注册的拦截器
                .addPathPatterns("/user/**","/product/**")  //不定长参数，自定义拦截请求路径 ，拦截所有: "/**"
                .excludePathPatterns("/user/aa");   //不定长参数，自定义不拦截的请求路径
    }
}		

注：
1. 使用本地main函数启动时拦截jsp；
2. 部署到tomcat中后，spring boot中的拦截器同样不拦截jsp（该jsp页面必须真正存在）