Spring Boot学习笔记

Spring Boot学习笔记
第一章 JavaConfig
1. 为什么要使用 Spring Boot
  因为Spring， SpringMVC 需要使用的大量的配置文件（xml文件）
  还需要配置各种对象，把使用的对象放入到spring容器中才能使用对象
  需要了解其他框架配置规则。
2. SpringBoot 就相当于不需要配置文件的Spring+SpringMVC。常用的框架和第三方库都已经配置好了。拿来就可以使用了。
3. SpringBoot开发效率高，使用方便多了
1.1 JavaConfig

JavaConfig: 使用java类作为xml配置文件的替代，是配置spring容器的纯java的方式。在这个java类这可以创建java对象，把对象放入spring容器中（注入到容器）。
使用两个注解：
1）@Configuration ：放在一个类的上面，表示这个类是作为配置文件使用的。
2）@Bean：声明对象，把对象注入到容器中。

1.2 @ImporResource

@ImportResource 作用导入其他的xml配置文件，等于在xml
```
<import resources="其他配置文件"/>
1
```
例如：
```
@Configuration
@ImportResource(value ={ "classpath:applicationContext.xml","classpath:beans.xml"})
public class SpringConfig {
}
1
2
3
4
```
1.3 @PropertyResource

@PropertyResource: 读取properties属性配置文件。使用属性配置文件可以实现外部化配置，
在程序代码之外提供数据。
步骤：
1. 在resources目录下，创建properties文件，使用k=v的格式提供数据
2. 在PropertyResource 指定properties文件的位置
3. 使用@Value（value=“${key}”）
```
@Configuration
@ImportResource(value ={ "classpath:applicationContext.xml","classpath:beans.xml"})
@PropertySource(value = "classpath:config.properties")
@ComponentScan(basePackages = "com.bjpowernode.vo")
public class SpringConfig {
}
1
2
3
4
5
6
```
第二章 Spring Boot

2.1 介绍

SpringBoot是Spring中的一个成员，可以简化Spring，SpringMVC的使用。他的核心还是IOC容器。
特点：
- Create stand-alone Spring applications
  创建spring应用
- Embed Tomcat, Jetty or Undertow directly (no need to deploy WAR files)
  内嵌的tomcat， jetty ， Undertow
- Provide opinionated ‘starter’ dependencies to simplify your build configuration
  提供了starter起步依赖，简化应用的配置。
  比如使用MyBatis框架，需要在Spring项目中，配置MyBatis的对象 SqlSessionFactory ， Dao的代理对象
  在SpringBoot项目中，在pom.xml里面, 加入一个 mybatis-spring-boot-starter依赖
- Automatically configure Spring and 3rd party libraries whenever possible
  尽可能去配置spring和第三方库。叫做自动配置（就是把spring中的，第三方库中的对象都创建好，放到容器中，开发人员可以直接使用）
- Provide production-ready features such as metrics, health checks, and externalized configuration
  提供了健康检查，统计，外部化配置
- Absolutely no code generation and no requirement for XML configuration
  不用生成代码，不用使用xml，做配置
2.2 创建Spring Boot项目

 2.2.1 第一种方式，使用Spring提供的初始化器，就是向导创建SpringBoot应用

使用的地址： https://start.spring.io

2.2.1 使用国内的地址

https://start.springboot.io

2.3 注解的使用
```
@SpringBootApplication
符合注解：由
@SpringBootConfiguration
@EnableAutoConfiguration
@ComponentScan

1.@SpringBootConfiguration

@Configuration
public @interface SpringBootConfiguration {
    @AliasFor(
        annotation = Configuration.class
    )
    boolean proxyBeanMethods() default true;
}

说明：使用了@SpringBootConfiguration注解标注的类，可以作为配置文件使用的，
    可以使用Bean声明对象，注入到容器

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
```
2.@EnableAutoConfiguration
启用自动配置，把java对象配置好，注入到spring容器中。例如可以把mybatis的对象创建好，放入到容器中
3.@ComponentScan
```
@ComponentScan 扫描器，找到注解，根据注解的功能创建对象，给属性赋值等等。
默认扫描的包： @ComponentScan所在的类所在的包和子包。
    
1
2
3
```
2.4 SpringBoot的配置文件

配置文件名称： application
扩展名有： properties( k=v) ; yml ( k: v)
使用application.properties, application.yml
例1：application.properties设置端口和上下文
```
#设置端口号
server.port=8082
#设置访问应用上下文路径， contextpath
server.servlet.context-path=/myboot

1
2
3
4
5
```
例2： application.yml
```
server:
  port: 8083
  servlet:
    context-path: /myboot2
1
2
3
4
```
2.5 多环境配置

有开发环境，测试环境，上线的环境。
每个环境有不同的配置信息，例如端口，上下文件，数据库url，用户名，密码等等
使用多环境配置文件，可以方便的切换不同的配置。
使用方式：创建多个配置文件，名称规则： application-环境名称.properties(yml)
创建开发环境的配置文件： application-dev.properties( application-dev.yml )
创建测试者使用的配置： application-test.properties

2.6 @ConfigurationProperties

@ConfigurationProperties: 把配置文件的数据映射为java对象。
属性：prefix 配置文件中的某些key的开头的内容。
```
@Component
@ConfigurationProperties(prefix = "school")
public class SchoolInfo {

    private String name;

    private String website;

    private String address;


    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getWebsite() {
        return website;
    }

    public void setWebsite(String website) {
        this.website = website;
    }

    public String getAddress() {
        return address;
    }

    public void setAddress(String address) {
        this.address = address;
    }

    @Override
    public String toString() {
        return "SchoolInfo{" +
                "name='" + name + '\'' +
                ", website='" + website + '\'' +
                ", address='" + address + '\'' +
                '}';
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
```
application.properties
```
#配置端口号
server.port=8082
#context-path
server.servlet.context-path=/myboot

#自定义key=value
school.name=uestc
school.website=www.uestc.com
school.address=chengdu

site=www.uestc.com
1
2
3
4
5
6
7
8
9
10
11
```
2.7 使用jsp

SpringBoot不推荐使用jsp ，而是使用模板技术代替jsp
使用jsp需要配置：
1）加入一个处理jsp的依赖。负责编译jsp文件
```
<dependency>
    <groupId>org.apache.tomcat.embedgroupId>
    <artifactId>tomcat-embed-jasperartifactId>
dependency>
1
2
3
4
```
1. 如果需要使用servlet， jsp，jstl的功能
```
<dependency>
	<groupId>javax.servletgroupId>
	<artifactId>jstlartifactId>
dependency>

<dependency>
	<groupId>javax.servletgroupId>
	<artifactId>javax.servlet-apiartifactId>
dependency>

<dependency>
<groupId>javax.servlet.jspgroupId>
	<artifactId>javax.servlet.jsp-apiartifactId>
	<version>2.3.1version>
dependency>

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
```
1. 创建一个存放jsp的目录，一般叫做webapp
  index.jsp
2. 需要在pom.xml指定jsp文件编译后的存放目录。
  META-INF/resources
  5）创建Controller，访问jsp
  6）在application.propertis文件中配置视图解析器
2.8 使用容器

你想通过代码，从容器中获取对象。
通过SpringApplication.run(Application.class, args); 返回值获取容器。
```
public static ConfigurableApplicationContext run(Class<?> primarySource, String... args) {
        return run(new Class[]{primarySource}, args);
}
ConfigurableApplicationContext : 接口，是ApplicationContext的子接口
public interface ConfigurableApplicationContext extends ApplicationContext
1
2
3
4
5
```
2.9 ComnandLineRunner 接口,ApplcationRunner接口

这两个接口都有一个run方法。执行时间在容器对象创建好后，自动执行run（）方法。
可以完成自定义的在容器对象创建好的一些操作。
```
@FunctionalInterface
public interface CommandLineRunner {
    void run(String... args) throws Exception;
}
@FunctionalInterface
public interface ApplicationRunner {
    void run(ApplicationArguments args) throws Exception;
}
1
2
3
4
5
6
7
8
```
第三章 Web组件

拦截器， Servlet ，Filter

3.1 拦截器

拦截器是SpringMVC中一种对象，能拦截器对Controller的请求。
拦截器框架中有系统的拦截器，还可以自定义拦截器。实现对请求预先处理。
实现自定义拦截器：
1. 创建类实现SpringMVC框架的HandlerInterceptor接口
public interface HandlerInterceptor {
default boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
return true;
}
```
default void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, @Nullable ModelAndView modelAndView) throws Exception {
}

default void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, @Nullable Exception ex) throws Exception {
}
1
2
3
4
5
```
}
```
2.需在SpringMVC的配置文件中，声明拦截器
```xml

 
 	
     
 

1
2
3
4
5
6
7
8
```
SpringBoot中注册拦截器：
```
@Configuration
public class MyAppConfig implements WebMvcConfigurer {

    //添加拦截器对象， 注入到容器中
    @Override
    public void addInterceptors(InterceptorRegistry registry) {

        //创建拦截器对象
        HandlerInterceptor interceptor = new LoginInterceptor();

        //指定拦截的请求uri地址
        String path []= {"/user/**"};
        //指定不拦截的地址
        String excludePath  [] = {"/user/login"};
        registry.addInterceptor(interceptor)
                .addPathPatterns(path)
                .excludePathPatterns(excludePath);

    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
```
3.2 Servlet

在SpringBoot框架中使用Servlet对象。
使用步骤：
1. 创建Servlet类。创建类继承HttpServlet
2. 注册Servlet ，让框架能找到Servlet
  例子：
  1.创建自定义Servlet
```
//创建Servlet类
public class MyServlet extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        doPost(req,resp);
    }

    @Override
    protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
       //使用HttpServletResponse输出数据，应答结果
        resp.setContentType("text/html;charset=utf-8");
        PrintWriter out  = resp.getWriter();
        out.println("===执行的是Servlet==");
        out.flush();
        out.close();

    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
```
1. 注册Servlet
```
@Configuration
public class WebApplictionConfig {

    //定义方法， 注册Servlet对象
    @Bean
    public ServletRegistrationBean servletRegistrationBean(){

        //public ServletRegistrationBean(T servlet, String... urlMappings)
        //第一个参数是 Servlet对象， 第二个是url地址

        //ServletRegistrationBean bean =
                //new ServletRegistrationBean( new MyServlet(),"/myservlet");


        ServletRegistrationBean bean = new ServletRegistrationBean();
        bean.setServlet( new MyServlet());
        bean.addUrlMappings("/login","/test"); // 


        return bean;
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
```
3.3 过滤器Filter

Filter是Servlet规范中的过滤器，可以处理请求，对请求的参数，属性进行调整。常常在过滤器中处理字符编码
在框架中使用过滤器：
1. 创建自定义过滤器类
2. 注册Filter过滤器对象
  例子：
```
// 自定义过滤器
public class MyFilter implements Filter {
    @Override
    public void doFilter(ServletRequest servletRequest, ServletResponse servletResponse, FilterChain filterChain) throws IOException, ServletException {
        System.out.println("执行了MyFilter，doFilter ");
        filterChain.doFilter(servletRequest,servletResponse);
    }
}
1
2
3
4
5
6
7
8
```
注册Filter
```
@Configuration
public class WebApplicationConfig {

    @Bean
    public FilterRegistrationBean filterRegistrationBean(){
        FilterRegistrationBean bean  = new FilterRegistrationBean();
        bean.setFilter( new MyFilter());
        bean.addUrlPatterns("/user/*");
        return bean;
    }
}
1
2
3
4
5
6
7
8
9
10
11
```
第四章 ORM 操作 MySQL

使用MyBatis框架操作数据，在SpringBoot框架集成MyBatis
使用步骤：
1. mybatis起步依赖：完成mybatis对象自动配置，对象放在容器中
2. pom.xml 指定把src/main/java目录中的xml文件包含到classpath中
3. 创建实体类Student
4. 创建Dao接口 StudentDao , 创建一个查询学生的方法
5. 创建Dao接口对应的Mapper文件， xml文件，写sql语句
6. 创建Service层对象，创建StudentService接口和他的实现类。去dao对象的方法。完成数据库的操作
7. 创建Controller对象，访问Service。
8. 写application.properties文件
  配置数据库的连接信息。
第一种方式： @Mapper

@Mapper：放在dao接口的上面，每个接口都需要使用这个注解。
```
/**
 * @Mapper：告诉MyBatis这是dao接口，创建此接口的代理对象。
 *     位置：在类的上面
 */
@Mapper
public interface StudentDao {

    Student selectById(@Param("stuId") Integer id);
}
1
2
3
4
5
6
7
8
9
```
第二种方式 @MapperScan
```
/**
 * @MapperScan: 找到Dao接口和Mapper文件
 *     basePackages：Dao接口所在的包名
 */
@SpringBootApplication
@MapperScan(basePackages = {"com.bjpowernode.dao","com.bjpowernode.mapper"})
public class Application {
}
1
2
3
4
5
6
7
8
```
第三种方式： Mapper文件和Dao接口分开管理

现在把Mapper文件放在resources目录下
1）在resources目录中创建子目录（自定义的），例如mapper
2）把mapper文件放到 mapper目录中
3）在application.properties文件中，指定mapper文件的目录
```
#指定mapper文件的位置
mybatis.mapper-locations=classpath:mapper/*.xml
#指定mybatis的日志
mybatis.configuration.log-impl=org.apache.ibatis.logging.stdout.StdOutImpl
1
2
3
4
```
1. 在pom.xml中指定把resources目录中的文件，编译到目标目录中
```
<resources>
   <resource>
      <directory>src/main/resourcesdirectory>
      <includes>
         <include>**/*.*include>
      includes>
   resource>
resources>
1
2
3
4
5
6
7
8
9
```
第四个事务

Spring框架中的事务：
1）管理事务的对象：事务管理器（接口，接口有很多的实现类）
例如：使用Jdbc或mybatis访问数据库，使用的事务管理器：DataSourceTransactionManager
2 ) 声明式事务：在xml配置文件或者使用注解说明事务控制的内容
控制事务：隔离级别，传播行为，超时时间
3）事务处理方式：
1） Spring框架中的@Transactional
2) aspectj框架可以在xml配置文件中，声明事务控制的内容
SpringBoot中使用事务：上面的两种方式都可以。
1）在业务方法的上面加入@Transactional , 加入注解后，方法有事务功能了。
2）明确的在主启动类的上面，加入@EnableTransactionManager
例子：
```
/**
 * @Transactional: 表示方法的有事务支持
 *       默认：使用库的隔离级别， REQUIRED 传播行为； 超时时间  -1
 *       抛出运行时异常，回滚事务
 */
@Transactional
@Override
public int addStudent(Student student) {
    System.out.println("业务方法addStudent");
    int rows  =  studentDao.insert(student);
    System.out.println("执行sql语句");

    //抛出一个运行时异常， 目的是回滚事务
    //int m   = 10 / 0 ;

    return rows;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
```
第五章接口架构风格 —RESTful

接口： API（Application Programming Interface，应用程序接口）是一些预先定义的接口（如函数、HTTP接口），或指软件系统不同组成部分衔接的约定。用来提供应用程序与开发人员基于某软件或硬件得以访问的一组例程，而又无需访问源码，或理解内部工作机制的细节。
接口（API）：可以指访问servlet， controller的url，调用其他程序的函数
架构风格： api组织方式（样子）

5.1 REST

RESTful架构风格
1)REST : （英文： Representational State Transfer , 中文：表现层状态转移)。
REST：是一种接口的架构风格和设计的理念，不是标准。
优点：更简洁，更有层次
表现层状态转移:
表现层就是视图层，显示资源的，通过视图页面，jsp等等显示操作资源的结果。
状态：资源变化
转移：资源可以变化的。资源能创建，new状态，资源创建后可以查询资源，能看到资源的内容，
这个资源内容，可以被修改，修改后资源和之前的不一样。
2）REST中的要素：
用REST表示资源和对资源的操作。在互联网中，表示一个资源或者一个操作。
资源使用url表示的，在互联网，使用的图片，视频，文本，网页等等都是资源。
资源是用名词表示。
对资源：
查询资源：看，通过url找到资源。
创建资源：添加资源
更新资源：更新资源，编辑
删除资源：去除

资源使用url表示，通过名词表示资源。
在url中，使用名词表示资源，以及访问资源的信息, 在url中，使用“ / " 分隔对资源的信息

使用http中的动作（请求方式），表示对资源的操作（CURD）
GET: 查询资源 – sql select

POST: 创建资源 – sql insert
在post请求中传递数据
```
<form action="http://localhost:8080/myboot/student" method="post">
	姓名：<input type="text" name="name" />
    年龄：<input type="text" name="age" />
  form>
1
2
3
4
```
PUT：更新资源 – sql update
```
<form action="http://localhost:8080/myboot/student/1" method="post">
 姓名：<input type="text" name="name" />
 年龄：<input type="text" name="age" />
      <input type="hidden" name="_method" value="PUT" />
form>
1
2
3
4
5
```
DELETE: 删除资源 – sql delete
xml 删除1的数据
需要的分页，排序等参数，依然放在 url的后面。

3）一句话说明REST：
使用url表示资源，使用http动作操作资源。
4) 注解
@PathVariable : 从url中获取数据
@GetMapping: 支持的get请求方式，等同于 @RequestMapping( method=RequestMethod.GET)
@PostMapping: 支持post请求方式，等同于 @RequestMapping( method=RequestMethod.POST)
@PutMapping: 支持put请求方式，等同于 @RequestMapping( method=RequestMethod.PUT)
@DeleteMapping: 支持delete请求方式，等同于 @RequestMapping( method=RequestMethod.DELETE)
@RestController: 符合注解，是@Controller 和@ResponseBody组合。
在类的上面使用@RestController ，表示当前类者的所有方法都加入了 @ResponseBody
5) Postman : 测试工具
使用Postman : 可以测试 get ，post ， put ，delete 等请求

 5.2 在页面中或者ajax中，支持put，delete请求

在SpringMVC中有一个过滤器，支持post请求转为put ,delete
过滤器： org.springframework.web.filter.HiddenHttpMethodFilter
作用：把请求中的post请求转为 put ， delete
实现步骤：
1. application.properties(yml) : 开启使用 HiddenHttpMethodFilter 过滤器
2. 在请求页面中，包含 _method参数，他的值是 put， delete ，发起这个请求使用的post方式
相关阅读:
从零开始学JAVA（03）：流程控制语句
 centos7安装chrome/Firefox浏览器
 基础 | 安全 - [加密]
认识华为OSN1500光接口板
 航空发动机轴承数据集 | 写论文再也不用担心没数据集啦！
代码随想录算法训练营动态规划part08
JS+jQuery常用方法笔记
 JDK中字体的高度信息ascent/descent/leading是怎么计算的
 串口实验言言
 时间序列分析1--生成和导出时间序列数据
原文地址：https://blog.csdn.net/mingshengda/article/details/125998142

第一章 JavaConfig

1.1 JavaConfig

1.2 @ImporResource

1.3 @PropertyResource

第二章 Spring Boot

2.1 介绍

2.2 创建Spring Boot项目

2.2.1 第一种方式， 使用Spring提供的初始化器， 就是向导创建SpringBoot应用

2.2.1 使用国内的地址

2.3 注解的使用

2.4 SpringBoot的配置文件

2.5 多环境配置

2.6 @ConfigurationProperties

2.7 使用jsp

2.8 使用容器

2.9 ComnandLineRunner 接口,ApplcationRunner接口

第三章 Web组件

3.1 拦截器

3.2 Servlet

3.3 过滤器Filter

第四章 ORM 操作 MySQL

第一种方式 ： @Mapper

第二种方式 @MapperScan

第三种方式： Mapper文件和Dao接口分开管理

第四个 事务

第五章 接口架构风格 —RESTful

5.1 REST

5.2 在页面中或者ajax中，支持put，delete请求

2.2.1 第一种方式，使用Spring提供的初始化器，就是向导创建SpringBoot应用

第一种方式： @Mapper

第四个事务

第五章接口架构风格 —RESTful