springboot学习笔记1

1、注解@SpringBootApplication的源码

          @SpringBootApplication封装spring注解的复合注解，包含@ComponentScan，和@SpringBootConfiguration，@EnableAutoConfiguration

@ComponentScan（包扫描）

• component是组件，scan是扫描，所以这个注解的含义就是用来扫描组件的，

• componentScan 扫描当前包及其子包下被 @Component，@Controller，@Service，@Repository注解标记的类并纳入到spring容器中进行管理，所以这个注解会自动注入所有在主程序所在包下的组件。默认把当前启动类所在的包作为扫描包的起点，例如咱们的项目，扫描 com.maweiqi 包

• 以前在ssm项目中我们需要去配置我们的包扫描

  <context:component-scan base-package="com.xxx"></context:component-scan>

  现在就用@componentScan可以代替

@SpringBootConfiguration :

        表示当前类具有配置类的作用

@EnableAutoConfiguration

        自动配置：根据当前引入的依赖包，猜测需要创建的工程类型，以及工程中有可能创建的对象，根据猜测自动创建工程所需的相关实例bean。

        程序启动，会自动加载扫描所有 classpath:/META-INF/spring.factories文件 ，并且创建对应实例

2.springboot集成Mybatis

2.1添加Mybatis的起步依赖

 <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.0.1.RELEASE</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>

    <properties>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
        <java.version>1.8</java.version>
    </properties>

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

        <!--SpingBoot集成junit测试的起步依赖-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>

        <!--mybatis起步依赖-->
        <dependency>
            <groupId>org.mybatis.spring.boot</groupId>
            <artifactId>mybatis-spring-boot-starter</artifactId>
            <version>1.1.1</version>
        </dependency>

        <!-- MySQL连接驱动 -->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
        </dependency>

    </dependencies>

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

2.2添加数据库连接信息

在 application.yml 中添加数据量的连接信息

mybatis:
  type-aliases-package: com.codecow.domain # 指定mybatis别名包
  mapper-locations: classpath:mappers/*.xml # 指定xml映射文件路径
logging:
  level:
    com.codecow.dao: debug # 配置日志
spring:
  datasource:
    username: root
    password: root
    url: jdbc:mysql://127.0.0.1:3306/springboot?useUnicode=true&characterEncoding=utf8
    driver-class-name: com.mysql.jdbc.Driver
server:
  port: 18081

SpringBoot的引言

Spring Boot是由Pivotal团队提供的全新框架，其设计目的是用来简化Spring应用的 初始搭建以及开发过程。该框架使用了特定的方式来进行配置，从而使开发人员不 再需要定义样板化的配置。通过这种方式，Spring Boot致力于在蓬勃发展的快速应 用开发领域(rapid application development)成为领导者。

Spring Boot 全新框架 作用: 简化spring应用初始搭建和开发过程

如何简化: 开发人员使用springboot只要基于特定方式进行配置 简化spring使用

SpringBoot 微框架: 5分钟 完成之前ssm中环境

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

SpringBoot的优势

1. 创建完整的独立的Spring应用程序 spring springmvc 只有一个容器

2. 嵌入的Tomcat，无需部署WAR文件 springboot 内嵌tomcat 应用跑在内嵌服务器

3. 简化Maven配置,自动配置Spring Springmvc,没有XML配置 几个依赖

   1. 用来springboot spring应用在无xml

• springboot 项目中必须在src/main/resources中放入application.yml(.properties)核心配置文件 名字必须为:application

• springboot 项目中必须在src/main/java中所有子包之外构建全局入口类型,xxApplication,入口类一个springboot项目只能有一个

环境搭建

# 1.System Requirements
        JDK1.8+
        MAVEN3.2+  
        Spring Framework 5.x+

# 2.ServletContainers:
        Tomcat 9.0+

# 3.开发工具
        IDEA    2021版本

新建项目中引入依赖

    <!--继承springboot的父项目-->
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.5.0</version>
    </parent>

    <dependencies>
      	<!--引入springboot的web支持-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
    </dependencies>

引入配置文件

项目中 src/main/resources/application.yml

编写入口类

//在项目中如下的包结构中创建入口类 Application

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

运行main启动项目

o.s.j.e.a.AnnotationMBeanExporter        : Registering beans for JMX exposure on startup
s.b.c.e.t.TomcatEmbeddedServletContainer : Tomcat started on port(s): 8080 (http)
com.baizhi.Application : Started Application in 2.152 seconds (JVM running for 2.611)
//说明:  出现以上日志说明启动成功 

建包并创建控制器

//在项目中创建指定的包结构

                    @Controller
                  @RequestMapping("/hello")
                  public class HelloController {
                    @RequestMapping("/hello")
                    @ResponseBody
                    public String hello(){
                          System.out.println("======hello world=======");
                      return "hello";
                    }
                  }

访问项目

# 注意: springboot的项目启动默认项目名
- 访问路径:  http://localhost:8080/hello/hello

修改内嵌服务器端口

server:
  port: 8989

修改应用名称

server:
  servlet:
    context-path: /springboot_day1

相关注解说明

# 入口类 SpringApplication
- SpringBootApplication: 全局入口类 有且只能有一个
- mian 函数参数可以在启动时指定jvm参数覆盖默认配置

# @SpringBootApplication 注解等价于:
- @SpringBootConfiguration           标识这是一个springboot的配置类,默认自定配置Spring环境
- @EnableAutoConfiguration                      自动与项目中集成的第三方技术进行集成
- @ComponentScan                                          扫描入口类所在子包以及子包后代包中注解   

配置文件

配置文件的拆分

说明: 在实际开发过程中生产环境和测试环境有可能是不一样的 因此将生产中的配置和测试中的配置拆分开,是非常必要的在springboot中也提供了配置文件拆分的方式. 这里以生产中项名名称不一致为例:

• 生产中项目名为: springboot

• 测试中项目名为: springboot_day1

• 端口同时为: 8080

# 主配置文件:
- application.yml    #用来书写相同的的配置
                server:
                    port: 8080 #生产和测试端口一致
                   
# 生产配置文件:
- application-prod.yml #prod为配置文件简名
                server:
                    context-path: /cmfz
    
#测试配置文件:
-    application-dev.yml  #dev为配置文件简名
                server:
                    context-path: /springboot

#在主配置中指定那个环境生效配置
spring:
  profiles:
    active: dev #指定那个环境配置生效 dev为环境配置文件的简名

启动指定配置文件

说明: 往往在企业级开发过程中为SpringBoot应用启动时指定一个完整外部配置也是经常用到的,在SpringBoot中也提供这个方式来启动项目如:

 

 

工厂创建对象

创建单个对象

在springboot中可以管理单个对象可以直接使用spring框架中注解形式创建。

• @Component 通用的对象创建注解

  • @Controller 用来创建控制器对象

  • @Service 用来创建业务层对象

  • @Repository 用来创建DAO层对象

    • 以上注解都有value属性，value属性用来指定工厂中对象名称

@Service
public class DemoServiceImpl implements UserService{
  //doing....
}   

# 2.通过工厂创建之后可以在使用处注入该对象

@Controller@RequestMapping("hello")
public class HelloController {    
@Autowired    
private DemoService demoService;    
//doing...}

创建多个对象

如何在springboot中像spring框架一样通过xml创建多个对象,在SpringBoot中也提供了相同注解如@Configuration + @Bean注解进行创建

• @Configuration 代表这是一个spring的配置类相当于Spring.xml配置文件

• @Bean 用来在工厂中创建这个@Bean注解标识的对象

  • 默认使用@Bean创建对象在工厂中唯一标识为方法名称

  • 修改在工厂中对象标识可以在使用@Bean("工厂中名字")指定一个名字

# 1.管理复杂对象的创建

@Configuration
public class Beans {
    @Bean
    public Calendar calendar(){
        return Calendar.getInstance();
    }
}

 # 2.使用复杂对象

@Controller
@RequestMapping("hello")
public class HelloController {
    @Autowired
    private Calendar calendar;
    ......
}

 # 注意:
                1.@Configuration 用来在工厂中一次性创建多个对象
              2.@Component     用来创建单个对象   

属性注入

基本属性注入

 # 1.@Value 属性注入               [重点]

@RestController
public class HelloController {
    //基本类型+String类型+日期类型
  	@Value("${name}")
    private String name;
    @Value("${age}")
    private Integer age;
    @Value("${sex}")
    private Boolean sex;
    @Value("${price}")
    private Double price;
    @Value("${bir}")
    private Date bir;
		//注入数组
    @Value("${qqs}")
    private String[] qqs;
  	//注入list
    @Value("${lists}")
    private List<String> lists;
  	//注入maps
    @Value("#{${maps}}")
    private Map<String,String> maps;
}

 # 2.在配置文件中定义注入值

name: 小陈
age: 23
price: 23.23
sex: true
bir: 2012/12/12

qqs: 123,3434,3434
lists: xiaochen,xiaoming,xiaosan

maps: "{'aa':'1234','bb':'2344'}"

• 注意: 这里面map集合注入比较特殊

对象方式注入

注意: 这种方式必须提供SET方法

 # 1. @ConfigurationProperties(prefix="前缀")

@Component
@ConfigurationProperties(prefix = "user")
public class User {
    private String id;
    private String name;
    private Integer age;
    private String  bir;
    //set 方法一定要提供
}

 # 2. 编写配置文件

user:
  id: 24
  name: xiaohei
  age: 23
  bir: 2012/12/12 

 # 3. 引入依赖构建自定义注入元数据

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

JSP模板集成

在SpringBoot框架中默认模板推荐使用Thymeleaf模板,这里我们优先讲与JSP模板集成

引入jsp的集成jar包

<!--c标签库-->
<dependency>
    <groupId>jstl</groupId>
    <artifactId>jstl</artifactId>
    <version>1.2</version>
</dependency>

<!--让内嵌tomcat具有解析jsp功能-->
<dependency>
    <groupId>org.apache.tomcat.embed</groupId>
    <artifactId>tomcat-embed-jasper</artifactId>
</dependency>

引入jsp运行插件

<build>
    <finalName>springboot_day1</finalName>
    <!--引入springboot插件 可以正确打包  显示jsp-->
    <plugins>
        <plugin>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-maven-plugin</artifactId>
        </plugin>
    </plugins>
</build>

配置视图解析器

#在配置文件中引入视图解析器
spring:
  mvc:
    view:
      prefix: /     # /代表访问项目中webapp中页面
      suffix: .jsp

整合Mybatis框架

引入依赖

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

<dependency>
  <groupId>mysql</groupId>
  <artifactId>mysql-connector-java</artifactId>
  <version>5.1.38</version>
</dependency>

<!--整合mybatis-->
<dependency>
  <groupId>org.mybatis.spring.boot</groupId>
  <artifactId>mybatis-spring-boot-starter</artifactId>
  <version>2.1.4</version>
</dependency>

<!--
  说明:由于springboot整合mybatis版本中默认依赖mybatis 因此不需要额外引入mybati版本,否则会出现冲突`-->

spring:
  mvc:
    view:
      prefix: /
      suffix: .jsp
  datasource:
    type: org.apache.commons.dbcp.BasicDataSource   #指定连接池类型
    driver-class-name: com.mysql.jdbc.Driver        #指定驱动
    url: jdbc:mysql://localhost:3306/ssm?characterEncoding=UTF-8           #指定url
    username: root									#指定用户名
    password: root								 	#指定密码

加入mybatis配置

#配置文件中加入如下配置:

mybatis:
  mapper-locations: classpath:com/baizhi/mapper/*.xml  #指定mapper配置文件位置
  type-aliases-package: com.baizhi.entity              #指定起别名所在包

//入口类中加入如下配置:
@SpringBootApplication
@MapperScan("com.baizhi.dao")   //必须在入口类中加入这个配置
public class Application {
    public static void main(String[] args) {
        SpringApplication.run(Application.class,args);
    }
}

MapperScan和Mapper的区别：

        @Mapperscan用在类上面，可以一次性扫描全部指定的dao包下面的接口

        @Mapper只能放在dao接口上面，创建一个接口就需要在接口上面写@Mapper，比较麻烦，建议使用，@MapperScan

本地测试

往往在开发过程中业务代码课程非常复杂频繁启动服务器测试,非常麻烦!这个时候使用本地测试就是一个很好的解决方案,springboot也提供了本地测试解决方案!

引入测试依赖

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

编写测试类

• @SpringBootTest

  • 修饰范围: 用在类上

  • 作用: 用来启动本地Spring环境

@SpringBootTest
public class TestEmpService {

    @Autowired
    private EmpService empService;

    @Test
    public void test(){
        empService.findAll().forEach(emp-> System.out.println(emp));
    }
}

热部署工具

为了进一步提高开发效率,springboot为我们提供了全局项目热部署,日后在开发过程中修改了部分代码以及相关配置文件后,不需要每次重启使修改生效,在项目中开启了springboot全局热部署之后只需要在修改之后等待几秒即可使修改生效。

开启热部署

项目中引入依赖 (每次搭建项目都需要引入)

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

# 1.开启自动编译

    Preferences | Build, Execution, Deployment | Compiler -> 勾选上 Build project automatically 这个选项

# 2.开启允许在运行过程中修改文件
    ctrl + alt + shift + / ---->选择1.Registry ---> 勾选 compiler.automake.allow.when.app.running 这个选项

 启动项目检测热部署是否生效

# 1.启动出现如下日志代表生效

2019-07-17 21:23:17.566  INFO 4496 --- [  restartedMain] com.baizhi.InitApplication               : Starting InitApplication on chenyannandeMacBook-Pro.local with PID 4496 (/Users/chenyannan/IdeaProjects/ideacode/springboot_day1/target/classes started by chenyannan in /Users/chenyannan/IdeaProjects/ideacode/springboot_day1)
2019-07-17 21:23:17.567  INFO 4496 --- [  restartedMain] com.baizhi.InitApplication               : The following profiles are active: dev
2019-07-17 21:23:17.612  INFO 4496 --- [  restartedMain] ationConfigEmbeddedWebApplicationContext : Refreshing org.springframework.boot.context.embedded.AnnotationConfigEmbeddedWebApplicationContext@66d799c5: startup date [Wed Jul 17 21:23:17 CST 2019]; root of context hierarchy
2019-07-17 21:23:18.782  INFO 4496 --- [  restartedMain] s.b.c.e.t.TomcatEmbeddedServletContainer : Tomcat initialized with port(s): 8989 (http)
2019-07-17 21:23:18.796  INFO 4496 --- [  restartedMain] o.apache.catalina.core.StandardService   : Starting service [Tomcat]
2019-07-17 21:23:18.797  INFO 4496 --- [  restartedMain] org.apache.catalina.core.StandardEngine  : Starting Servlet Engine: Apache Tomcat/8.5.20 

 注意:日志出现restartedMain代表已经生效,在使用热部署时如果遇到修改之后不能生效,请重试重启项目在试

日志处理

引言

springboot框架 集成日志 logback 日志

Logback是由log4j创始人设计的又一个开源日志组件。目前，logback分为三个模块：logback-core，logback-classic和logback-access。是对log4j日志展示进一步改进!

总结: logback 也是一个开源日志组件 和 log4j作用一致 都是用来生成日志 logback更加轻量

日志的级别

> All < Trace < `DEBUG < INFO < WARN < ERROR` < Fatal < OFF

- OFF   | 关闭：最高级别，不打印日志。
- FATAL | 致命：指明非常严重的可能会导致应用终止执行错误事件。
- ERROR | 错误：指明错误事件，但应用可能还能继续运行。
- WARN | 警告：指明可能潜在的危险状况。
- INFO | 信息：指明描述信息，从粗粒度上描述了应用运行过程。
- DEBUG | 调试：指明细致的事件信息，对调试应用最有用。
- TRACE | 跟踪：指明程序运行轨迹，比DEBUG级别的粒度更细。
- ALL | 所有：所有日志级别，包括定制级别。

> 日志级别由低到高:  `日志级别越高输出的日志信息越多`

项目中日志分类

# 日志分类:
- 一种是rootLogger(根全局日志) :     用来监听项目中所有的运行日志 包括引入依赖jar中的日志

- 一种是logger(指定包级别日志) :         用来监听项目中指定包中的日志信息

配置日志

注意:SpringBoot框架中默认根日志为INFO

logging:
  level:
    root: debug #指定根日志级别(一般不推荐修改根日志,输出信息太多,推荐使用子日志)
    com.baizhi.dao: debug #指定某个包中日志
  file:
    name: aaa.log #指定日志名称
    path: ./  #指定日志文件目录

项目中使用日志

@Controller
public class HelloController {
    //声明日志成员
    private static final Logger log = LoggerFactory.getLogger(HelloController.class);
    @RequestMapping("/hello")
    @ResponseBody
    public String hello(){
        System.out.println("======hello world=======");
        logger.debug("DEBUG,{}","信息");
        logger.info("INFO,{}","信息");
        logger.warn("WARN,{}","信息");
        logger.error("ERROR,{}","信息");
        return "hello";
    }
}

切面编程

引言

springboot是对原有项目中spring框架和springmvc的进一步封装,因此在springboot中同样支持spring框架中AOP切面编程,不过在springboot中为了快速开发仅仅提供了注解方式的切面编程.

使用

引入依赖

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

相关注解

# 切面注解
- @Aspect 用来类上,代表这个类是一个切面
- @Before 用在方法上代表这个方法是一个前置通知方法
- @After 用在方法上代表这个方法是一个后置通知方法
- @Around 用在方法上代表这个方法是一个环绕的方法 

前置切面  

@Aspect
@Configuration
public class MyAspect {
    @Before("execution(* com.baizhi.service.*.*(..))")
    public void before(JoinPoint joinPoint){
        System.out.println("前置通知");
        joinPoint.getTarget();//目标对象
        joinPoint.getSignature();//方法签名
        joinPoint.getArgs();//方法参数
    }
}

后置切面

@Aspect
@Configuration
public class MyAspect {
    @After("execution(* com.baizhi.service.*.*(..))")
    public void before(JoinPoint joinPoint){
        System.out.println("后置通知");
        joinPoint.getTarget();//目标对象
        joinPoint.getSignature();//方法签名
        joinPoint.getArgs();//方法参数
    }
}

注意: 前置通知和后置通知都没有返回值,方法参数都为joinpoint

环绕切面

@Aspect
@Configuration
public class MyAspect {
    @Around("execution(* com.baizhi.service.*.*(..))")
    public Object before(ProceedingJoinPoint proceedingJoinPoint) throws Throwable {
        System.out.println("进入环绕通知");
        proceedingJoinPoint.getTarget();//目标对象
        proceedingJoinPoint.getSignature();//方法签名
        proceedingJoinPoint.getArgs();//方法参数
        Object proceed = proceedingJoinPoint.proceed();//放行执行目标方法
        System.out.println("目标方法执行之后回到环绕通知");
        return proceed;//返回目标方法返回值
    }
}

注意: 环绕通知存在返回值,参数为ProceedingJoinPoint,如果执行放行,不会执行目标方法,一旦放行必须将目标方法的返回值返回,否则调用者无法接受返回数据

文件上传下载

文件上传

用户访问当前系统,将自己本地计算机中文件通过浏览器上传到当前系统所在的服务器过程中称之为文件的上传

文件上传: 用户将自己计算机中文件 上传到 项目所在服务器过程、文件服务器、OSS 称之为文件上传

准备上传页面

<form action="路径...." method="post" enctype="multipart/form-data">
        <input type="file" name="aa">
        <input type="submit" value="上传">
</form>
<!--
	1. 表单提交方式必须是post
	2. 表单的enctype属性必须为multipart/form-data
	3. 后台接受变量名字要与文件选择name属性一致
-->

注意：文件上传中上传的类型是二进制类型，enctype必须指定为enctype="multipart/form-data",enctype默认为enctype="application/x-www-form-urlencoded"