• Spring Boot学习笔记

    SpringBoot特征

    特征

    • 创建独立的 Spring 应用程序

    • 直接嵌入 Tomcat、Jetty 或 Undertow（无需部署 WAR 文件）

    • 提供“入门”依赖项以简化构建配置

    • 尽可能自动配置 Spring 和 第三方库

    • 提供生产就绪功能，例如指标、健康检查和外部化配置

    • 完全无需代码生成，无需 XML 配置

    创建SpringBoo项目

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

    1.IEDA创建一个空项目

    2.新建一个Module

    还可以使用国内地址（镜像)  ​ https://start.springboot.io

     3.

    4.选择依赖项

     5.

     6.

     7.配置好的SpringBoot目录结构

     8.

    @Controller：后端控制器

    @RequestMapping("/hello")：访问路径

    @ResponseBody：将controller的方法返回的对象通过适当的转换器转换为指定的格式之后，写入到response对象的body区，通常用来返回JSON数据

     9.

    10.去浏览器访问 @RequestMapping("/hello")地址

     多环境配置

            在实际开发过程中，项目会经历很多阶段（开发->测试->上线）,每个阶段的配置也会不同，例如，端口，上下文跟，数据库，那么这个时候为了方便不同环境之间的切换，SpringBoot提供了多环境配置，具体步骤如下

    项目名:006-SpringBoot-multi-asdn

    为每个环境创建一个配置文件，命名必须以application-环境标识.yml

    注解

    一、@controller：   controller控制器层（注入服务）
    二、@service ：      service服务层（注入dao）
    三、@repository ：  dao持久层（实现dao访问）
    四、@component：  标注一个类为Spring容器的Bean，（把普通pojo实例化到spring容器中，至关于配置文件中的）    spring

    @ConfigurationProperties

    1. 在SpringBoot中，当需要获取到配置文件数据时，除了可以用Spring自带的@Value注解外，
    2. SpringBoot提供了一种更加方便的方式：@ConfigurationProperties。
    3. 只要在bean上添加上这个注解，指定好配置文件的前缀，那么对应的配置文件数据就会自动填充到bean中。
    4. 举个栗子，现在有如下配置：
    5. 1 myconfig.name=test
    6. 2 myconfig.age=22
    7. 3 myconfig.desc=这是我的测试描述
    8. 	
    9.  
    10. 添加对应的配置类，并添加上注解@ConfigurationProperties，指定前缀为myconfig
    11. 1 @Component
    12. 2 @ConfigurationProperties(prefix = "myconfig")
    13. 3 public class MyConfig {
    14. 4 private String name; //属性名要和配置文件中的名字一样
    15. 5 private Integer age; //属性名要和配置文件中的名字一样
    16. 6 private String desc; //属性名要和配置文件中的名字一样
    17. 7     //get//set 略
    18. 8 @Override
    19. 9 public String toString() {
    20. 10  return "MyConfig [name=" + name + ", age=" + age + ", desc=" + desc + "]";
    21. 11 }
    22. 12}
    23. 	
    24.  
    25.

    使用容器

    获取容器中的对象

    CommandLineRunner 接口

    在开发中会有这样的情景，需要在容器启动后执行一些内容，比如读取配置文件，数据库连接之类的，SpringBoot给提供了两个接口帮我们实现这种需求，这两个接口分别为CommandLineRunner和ApplicationRunner。他们的执行时机为容器启动完成的时候，这两个接口中有一个run方法，只需要实现这个方法即可。这两个接口的不同之处在于：ApplicationRunner中run方法的参数为ApplicationArguments，而CommandLineRunner接口中run方法的参数为String数组

     Web组件

    拦截器

    拦截器是SpringMVC中的一种对象，能拦截对COntroller的请求

    拦截器框架中有系统的拦截器，还可以自定义拦截器，实现对请求的拦截

    实现自定义拦截器：创建类去实现HandlerInterceptor接口重写方法

    1. package org.springframework.web.servlet;
    2.  
    3. import javax.servlet.http.HttpServletRequest;
    4. import javax.servlet.http.HttpServletResponse;
    5. import org.springframework.lang.Nullable;
    6.  
    7. public interface HandlerInterceptor {
    8.     default boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
    9.         return true;
    10.     }
    11.  
    12.     default void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, @Nullable ModelAndView modelAndView) throws Exception {
    13.     }
    14.  
    15.     default void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, @Nullable Exception ex) throws Exception {
    16.     }
    17. }

    需要在SpringMVC的配置文件中，声明拦截器

    1. <mvc:interceptors>
    2.     <mvc:interceptor>
    3.         <mvc:path="url"/>
    4.         <bean class="拦截器类全限定名称"/>
    5.     </mvc:interceptor>
    6. </mvc:interceptors>

    SpringBoot中拦截器

    1.创建一个类去实现HandlerInterceptor接口重写preHandle方法

     2.通过WebMvcConfigurer接口实现一个配置类,再通过@Configuration 注解注入到容器

    1.  
    2. /**
    3.  * 拦截器注入到容器中
    4.  */
    5. @Configuration
    6. public class MyappConfig implements WebMvcConfigurer {
    7.  
    8.     
    9.     @Override
    10.     public void addInterceptors(InterceptorRegistry registry) {
    11.  
    12.         //创建拦截器对象
    13.         HandlerInterceptor interceptor = new Interceptor();
    14.  
    15.         //指定拦截的请求url
    16.         String[] url = {"/user/**"};
    17.         //不拦截的url请求地址
    18.         String[] path ={"/user/login"};
    19.         registry.addInterceptor(interceptor).addPathPatterns(url).excludePathPatterns(path);
    20.     }
    21. }

    3.创建controller去实验一下

     4.运行程序访问/user/acc和/user/login

    访问/user/acc地址，拦截器中的preHandle方法执行了，说明该请求被拦截器拦截

     

    SpringBoot 中Servlet

    1.自定义一个servlet类

     2.注册servlet

     SpringBoot中使用Filter

    实现步骤：

    1.创建Filter对象

     2.FilterRegistrationBean用来注册Filter对象

     字符集过滤器

    CharacterEncodingFilter:解决post请求中乱码的问题

    实现步骤：

    1.配置字符集过滤器

    1.  
    2. @Configuration
    3. public class WebApplicationConfig {
    4.  
    5.     @Bean
    6.     public ServletRegistrationBean servletRegistrationBean(){
    7.         ServletRegistrationBean bean = new ServletRegistrationBean(new Myservlet(),"/myservlet");
    8.  
    9.         return bean;
    10.     }
    11.  
    12.  
    13.  
    14.     /*配置字符集过滤器*/
    15.  
    16.     @Bean
    17.     public FilterRegistrationBean filterRegistrationBean(){
    18.         FilterRegistrationBean filter = new FilterRegistrationBean();
    19.  
    20.         //使用框架中的过滤器
    21.         CharacterEncodingFilter characterEncodingFilter = new CharacterEncodingFilter();
    22.         //指定编码的格式
    23.         characterEncodingFilter.setEncoding("utf-8");
    24.         //指定request，response都使用utf-8编码
    25.         characterEncodingFilter.setForceEncoding(true);
    26.  
    27.         filter.setFilter(characterEncodingFilter);
    28.         filter.addUrlPatterns("/*");
    29.         return filter;
    30.     }
    31. }

    2.修改application.properties文件，让自定义过滤器起作用

    1. #springboot中默认是配置了CharacterEncodingFilter。默认编码ISO-8859-1
    2. #设置为false，关闭默认配置使用自定义字符过滤器
    3. server.servlet.encoding.enabled=false

    第二种修改字符集方式：

     ORM操作MySQL

    在SpringBoot框架中集成MyBatis

    使用步骤：

    1.添加mybatis起步依赖

    2.pom.xml指定把src/main/java目录中的xml文件包含classpath中

    3.创建实体类

    4.创建Dao接口，创建查询方法

     5.创建Dao接口对应的Mapper文件

    6.创建servlice接口和实现类，去调Dao接口中的方法

    7.创建Controller层，去调用service中的方法

    8.写application.properties文件

     9.在启动类上添加@MapperScan(basePackages = "com.demo.dao")

     10.启动springboot测试就ok

            第二种方式：Mapper文件和dao接口分开管理（推荐使用）

            1.在resources目录中创建子目录（自定义），例如，mapper

            2.把mapper.xml文件放到mapper目录中

            3.在application.properties文件中，指定mapper.xml文件的位置 

    mybatis.mapper-locations=classpath:mapper/*.xml

            4.在pom.xml中指定把resources目录中的文件，编译到目标目录中

    1. <resources>
    2. 	<resource>
    3. 		<directory>src/main/resources</directory>
    4. 			<includes>
    5. 				<include>**/*.*</include>
    6. 			</includes>
    7. 	</resource>
    8. </resources>

    事务

    spring框架中的事务

    1.管理事务的对象：事务管理器（接口，接口有很多实现类）

            例如，使用jdbc和mybatis访问数据库，使用的事务管理器：DataSourceTransactionManager

    2.声明事务：在xml配置文件或使用注解方式说明事务控制的内容

            控制事务：隔离级别、传播行为、超时时间

    3.事务处理方式

            Spring框架中注解@Transactional

            aspecJ框架可以在xml配置文件中，声明事务控制的内容

    SpringBoot中使用事务：以上两种方式都可以，这里使用注解方式

    1.在业务方法上面加入@Transactional，加入注解方法就有事务功能了

    2.在主启动类上面加入，@EnableTransactionManager

    SpringBoot中使用Redis数据库

    1.启动Redis服务，客户端连接redis服务

    2.IEDA中新建模块，依赖项选择Web 和 NoSQL

    3.在application.properties配置文件中添加连接redis数据库ip和端口

    4.写个测试类访问redis数据库

    1.  
    2. @RestController
    3. public class RedisController {
    4.     @Resource
    5.     private RedisTemplate redisTemplate;
    6.  
    7.     @GetMapping("/redis/set")
    8.     public String addredis(String name,String value){
    9.        /*通过RedisTemplate类中的opsForValue()方法可以操控redis数据库中String类型的数据*/
    10.         ValueOperations redis = redisTemplate.opsForValue();
    11.         redis.set("myname","lisi");
    12.         return "向redis数据库添加String类型数据";
    13.     }
    14.  
    15.     @GetMapping("/redis/get")
    16.     public String getredis(String key){
    17.         ValueOperations redis = redisTemplate.opsForValue();
    18.         String v = (String) redis.get(key);
    19.         return key+":::"+v;
    20.     }
    21. }

    以上两个方法执行结果都会被序列化成二进制数据，第一个方法写入redis数据库中的数据被序列化，我们查看很不方便，如下图

     这时候就要使用序列化和反序列化技术

    Redis序列化

     序列化：把对象转化为可以传输的字节序列过程称为序列化

    反序列化：把字节序列还原为对象的过程称为反序列化

    Q为什么要序列化？

    序列化最终的目的是为了对象可以跨平台存储，和进行网络传输。跨平台存储和网络传输的方式就是IO，而IO支持的数据格式就是字节数据，再把对象转成字节数组的时候制定一种规则(序列化)，我们从IO流里读取数据的时候再以制定的规则把对象还原回来(反序列化)

    序列化的方式？

    常见的序列化方式有：jdk(不支持跨语言)、JSON、XML、Hessian等。

    java的序列化：把java对象转换为byte[]，二进制数据。

    json序列化：是将java对象转换成字符串：{"name":"李四"，"age":"22"}，反序列化是将

    {"name":"李四"，"age":"22"}转换成java对象，对象属性是name，值是李四。

    设置RredisTemplate序列化

    可以设置key的序列化、也可以只设置value的序列化，也可以同时都设置

    使用json序列化，把java对象转换为json字符串存储

    1.创建一个student类实现Serializable接口，并添加序列化版本号

     2.使用json序列化把一个java对象存储到redis数据库

     3.使用json反序列化从redis中取出刚才存储的java对象显示在页面上

             输出结果

    springBoot集成Dubbo

    1.创建接口

    创建一个接口项目，该项目只定义接口和实体类，此项目就是一个普通的maven项目

    2.服务提供者

    新建一个项目使用Spring 初始化器创建，不用选择依赖项，实现接口项目里的接口

    在pom.xml文件中添加依赖

    1.         <!--接口依赖-->
    2. 		<dependency>
    3. 			<groupId>com.song</groupId>
    4. 			<artifactId>014-interface-api</artifactId>
    5. 			<version>1.0.0</version>
    6. 		</dependency>
    7. 		<!--dubbo依赖-->
    8. 		<dependency>
    9. 			<groupId>org.apache.dubbo</groupId>
    10. 			<artifactId>dubbo-spring-boot-starter</artifactId>
    11. 			<version>2.7.8</version>
    12. 		</dependency>
    13.  
    14. 		<!--zookeeper注册中心依赖-->
    15. 		<dependency>
    16. 			<groupId>org.apache.dubbo</groupId>
    17. 			<artifactId>dubbo-dependencies-zookeeper</artifactId>
    18. 			<version>2.7.8</version>
    19. 			<type>pom</type>
    20.             <exclusions>
    21. 				<exclusion>
    22. 					<groupId>org.slf4j</groupId>
    23. 					<artifactId>slf4j-log4j12</artifactId>
    24. 				</exclusion>
    25. 			</exclusions>
    26. 		</dependency>
    27. 	</dependencies>

    创建一个StudentServiceImpl类实现StudentService接口，并在类上添加暴露接口的注解

     在application.properties文件中添加配置

    1.  
    2. #配置服务名称
    3. spring.application.name=studentservice-provider
    4.  
    5. #配置扫描包，扫描的@DubboService
    6. dubbo.scan.base-packages=com.song.service
    7.  
    8. #配置dubbo协议,使用注册中心，不用配置协议
    9. #dubbo.protocol.name=dubbo
    10. #dubbo.protocol.port=8081
    11.  
    12. #注册中心
    13. dubbo.registry.address=zookeeper://localhost:2181

    在启动类上方添加@EnableDubbo注解

    @EnableDubbo注解含义是启用Dubbo，下包含两个注解：

            @EnableDubboConfig

            @DubboComponentScan：扫描Dubbo注解

    3.创建消费者

    新建一个项目使用Spring 初始化器创建，不选择依赖，创建好后，把以下依赖添加到pom文件中

    1. <!--web起步依赖-->
    2. 		<dependency>
    3. 			<groupId>org.springframework.boot</groupId>
    4. 			<artifactId>spring-boot-starter-web</artifactId>
    5. 		</dependency>
    6.  
    7. 		<!--接口依赖-->
    8. 		<dependency>
    9. 			<groupId>com.song</groupId>
    10. 			<artifactId>014-interface-api</artifactId>
    11. 			<version>1.0.0</version>
    12. 		</dependency>
    13. 		<!--dubbo依赖-->
    14. 		<dependency>
    15. 			<groupId>org.apache.dubbo</groupId>
    16. 			<artifactId>dubbo-spring-boot-starter</artifactId>
    17. 			<version>2.7.8</version>
    18. 		</dependency>
    19.  
    20. 		<!--zookeeper注册中心依赖-->
    21. 		<dependency>
    22. 			<groupId>org.apache.dubbo</groupId>
    23. 			<artifactId>dubbo-dependencies-zookeeper</artifactId>
    24. 			<version>2.7.8</version>
    25. 			<type>pom</type>
    26. 			<exclusions>
    27. 				<exclusion>
    28. 					<groupId>org.slf4j</groupId>
    29. 					<artifactId>slf4j-log4j12</artifactId>
    30. 				</exclusion>
    31. 			</exclusions>
    32. 		</dependency>

    创建Controller类

     在启动类上面添加@EnableDubbo注解

     在application.properties文件中添加一下内容

    1.  
    2. #指定服务名称
    3. spring.application.name=consumer-application
    4.  
    5. #指定注册中心
    6. dubbo.registry.address=zookeeper://localhost:2181

    SpringBoot 打 war包

    1.在pom.xml文件中修改打包格式，默认是打jar包

     2.修改打包后的名字

     3.启动类继承SpringBootServletInitializer类，重写configure方法

     

     4.开始打包，IDEA工具栏Build->Build Artifact->选中要打包的项目->Build
     

     

     SpringBoot打jar包
     

    1.在pom.xml文件中指定maven-plugin插件的版本号
     

     

     2.下面步骤跟打war包的步骤2和4一样
     

     

    Thymeleaf模板引擎
     

    SpringBoot集成了Thymeleaf模板技术，并且SpringBoot官方也推荐使用Thymeleaf来代替JSP技术，Thymeleaf是另外的一张模板技术，它本身不属于SpringBoot，SpringBoot只是很好地集成这种模板技术，作为前端页面的数据展示，在过去的 java web开发中，我们往往会使用jsp去完成页面的动态渲染，但是jsp需要翻译编译运行，效率低。
     

     

    第一个例子
     

    1.使用spring初始化器创建一个模块，
     

     

     2.勾选依赖，如下图
     

     

     3.写controller
     

     

     4.在templates文件夹中新建一个html文件
     

     

    5.启动类运行访问controller的地址/acc
     

     

     Thymeleaf表达式
     

    表达式是在页面获取数据的一种thymeleaf语法，类似${key}
     

    标准变量表达式
     

            注意：th:text=""是Thymeleaf的一个属性，用于文件的显示
     

    说明：标准变量表达式用于访问容器tomcat上下文环境中的变量，Thymeleaf中的变量表达式使用${变量名}的方式获取Controller中model其中的数据，也就是request作用域中的数据
     

     

     选择变量表达式
     

    星号变量表达式
     

    语法：*{key}
     

    作用：获取这个key对应的数据，*{key}需要和th:object这个属性一起使用。
     

    目的：简化获取对象的属性值。
     

     

    链接表达式
     

    语法：@{url}
     

    作用：表示连接
     

     

     

     

     

    
                
    
                    
    
                
    • 

                
  • 

                    相关阅读:
    
                    
软件测试知识库+1，5款顶级自动化测试工具推荐和使用分析                            
    
Android学习笔记 11. RelativeLayout 相对布局                            
    
JAVA微信小程序图书馆座位预约小程序系统毕业设计 开题报告                            
    
“清华女神”回国，赤子之心，如愿以偿                            
    
20世纪最佳12部学术专著                            
    
2024.2.29 模拟实现 RabbitMQ —— 项目展示                            
    
土巴兔面试题                            
    
c++——AVL树                            
    
從turtle海龜動畫 學習 Python - 高中彈性課程系列 10.2 藝術畫 Python 製作生成式藝術略覽                            
    
组长给组员派活，把组长自己的需求和要改的bug派给组员，合理吗？                            
    
                        
                
    • 
                
  • 
                    原文地址：https://blog.csdn.net/caijigskg/article/details/125358968
                
    •