开发: C++知识库 Java知识库 JavaScript Python PHP知识库人工智能区块链大数据移动开发嵌入式开发工具数据结构与算法开发测试游戏开发网络协议系统运维
教程: HTML教程 CSS教程 JavaScript教程 Go语言教程 JQuery教程 VUE教程 VUE3教程 Bootstrap教程 SQL数据库教程 C语言教程 C++教程 Java教程 Python教程 Python3教程 C#教程
数码: 电脑笔记本显卡显示器固态硬盘硬盘耳机手机 iphone vivo oppo 小米华为单反装机图拉丁

-> Java知识库 -> SpringBoot -> 正文阅读

[Java知识库]SpringBoot

1.SpringBoot

1.1JavaConfig

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

/*配置文件
* 位置：类上面
* 相当于beans.xml*/
@Configuration
public class SpringConfig {
    /*创建方法，方法返回值的是对象，在方法上加@Bean
    * 方法的返回值对象就注入到容器中
    *@Bean：把对象注入到spring容器中，作用相当于<bean>
    *位置：方法上
    */
    @Bean
    public Student createStudent(){
        Student student = new Student();
        student.setName("李四");
        student.setAge(20);
        student.setSex("男");
        return student;
    }
    @Bean("wangStudent")
    public Student makeStudent(){
        Student student = new Student();
        student.setName("王五");
        student.setAge(18);
        student.setSex("男");
        return student;
    }
}

1.2@ImprotResource

@importResource
- 作用导入其他的xml配置文件，等于在xml

<import resource="其他配置文件"/>

@ImportResource(value = "classpath:beans.xml")

1.3@PropertyResource

@PropertyResource
- 读取properties属性配置文件，使用属性配置文件可以实现外部化配置，在程序代码之外提供数据
步骤：
- resource目录下，创建properties文件，使用k=v的格式提供数据
- 在PropertyResource指定properties文件的位置
- 使用@Value(value=“${key}”)

@Configuration
@ImportResource(value = "classpath:beans.xml")
@PropertySource(value = "classpath:config.properties")
@ComponentScan(basePackages = "com.springboottest.vo")
public class SpringConfig {
}

2.Spring Boot

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

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

2.2第二种方式，国内地址

国内地址：https://start.springboot.io

2.3注解的使用

@SpringBootApplication

@SpringBootApplication
符合注解
@SpringBootConfiguration
@EnableAutoConfiguration
@ComponentScan
1.@SpringBConfiguration
@Configuration
public @interface SpringBootConfiguration {
    @AliasFor(
        annotation = Configuration.class)
    boolean proxyBeanMethods() default true;
}
说明：使用了@SpringBootConfiguration注解标注的类，可以作为配置文件使用，可以使用Bean声明对象，注入到容器

@EnableAutoConfiguration
- 启动自动配置，把java对象配置好，注入到spring容器中
@ComponentScan
- 扫描器，找到注解，根据注解功能创建对象，给对象赋值等
- 默认扫描@ComponentScan所在的类所在的包和子包

2.4SpringBoot的配置文件

配置文件名称
- application
扩展名：properties(k=v);yml(k:v)
application.properties

#端口号
server.port=8080
#上下文
server.servlet.context-path=/boot

application.yml

server:
  port: 8081
  servlet:
    context-path: /head

2.5多环境配置

开发环境、测试环境、上线环境
不同环境有不同的配置信息
使用多环境配置文件，方便切换不同的配置
使用方式
- 创建多个配置文件
  - 命名规则
    - application-环境名字.properties(yml)

2.6使用JSP

springboot不推荐使用jsp

使用jsp需要配置

加入一个处理jsp的依赖，负责编译jsp文件

<dependency>
    <groupId>org.apache.tomcat.embed</groupId>
    <artifactId>tomcat-embed-jsper</artifactId>
</dependency>

如果需要使用servlet，jsp，jstl的功能

 <dependency>
  	<groupId>javax.servlet</groupId>
    <artifactId>javax.servlet-api</artifactId>
</dependency>
<dependency>
	<groupId>javax.servlet.jsp</groupId>
    <artifactId>javax.servlet.jsp-api</artifactId>
</dependency>
<dependency>
	<groupId>javax.servlet</groupId>
    <artifactId>jstl</artifactId>
</dependency>

创建一个存放jsp的目录，一般叫做web.app
- index.jsp
需要在pom.xml指定jsp文件编译后的存放目录
- META-INF/resource
创建Controller，访问jsp
在application.properties文件中配置视图解析器

2.7 使用容器

通过代码，从容器中获取对象
通过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

2.8ComnandLineRunner接口，ApplicationRunner接口

这两个接口都有一个run方法，执行时间在容器创建好后，自动执行run()方法
可以完成自定义在容器对象创建好的一些操作

@FunctionalInterface
public interface CommandLineRunner {
    void run(String... args) throws Exception;
}

@FunctionalInterface
public interface ApplicationRunner {
    void run(ApplicationArguments args) throws Exception;
}

3Web组件

拦截器
Servlet
Filter

3.1拦截器

拦截器是SpringMVC中的一种对象，能拦截对Controller的请求
拦截器框架中有拦截器，还可以自定义拦截器，实现对请求预先处理
实现自定义拦截器
- 创建类实现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 { }
}

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

<mvc:interceptors>
    <mvc:interceptor>
        <mvc:path="url"/>
        <bean class="拦截器类全限定名"/>
    </mvc:interceptor>
</mvc:interceptors>

SpringBoot注册拦截器

@Configuration
public class MyAppConfig implements WebMvcConfigurer {
    //添加拦截器对象，注入到容器中
    @Override
    public void addInterceptors(InterceptorRegistry registry) {
        HandlerInterceptor interceptor = new LoginInterceptor();
        String path [] = {"/user/**"};
        String excludePath [] = {"/user/login"};
        registry.addInterceptor(interceptor).addPathPatterns(path).excludePathPatterns(excludePath);
    }
}

3.2Servlet

在SpringBoot框架中使用Servlet对象
步骤
- 创建Servlet类，创建类继承HttpServlet
- 注册Servlet，让框架能找到Servlet

@Configuration
public class WebApplicationConfig {
    @Bean
    /*定义方法注册Servlet对象*/
    public ServletRegistrationBean servletRegistrationBean(){
        /* public ServletRegistrationBean(T servlet, String... urlMappings)
        * T servlet Servlet对象
        * String... urlMappings url对象
        * */
        //ServletRegistrationBean bean = new ServletRegistrationBean(new MyServlet(),"/myservlet");
        ServletRegistrationBean bean = new ServletRegistrationBean();
        bean.setServlet(new MyServlet());
        bean.addUrlMappings("/login","/test");
        return bean;
    }
}

3.3过滤器Filter

Filter是Servlet规范中的过滤器，可以处理请求，对请求的参数、属性进行调整。常在过滤器中处理字符编码

在框架中使用过滤器

创建自定义过滤器类


public class MyFilter implements Filter {
    @Override
    public void doFilter(ServletRequest servletRequest, ServletResponse servletResponse, FilterChain filterChain) throws IOException, ServletException {
        System.out.println("Filter.........");
        filterChain.doFilter(servletRequest,servletResponse);
    }
}

注册Filter过滤器对象

    @Bean
    public FilterRegistrationBean filterRegistrationBean(){
        FilterRegistrationBean bean = new FilterRegistrationBean();
        bean.setFilter(new MyFilter());
        bean.addUrlPatterns("/user/*");
        return bean;
    }

3.4字符集过滤器

CharacterEncodingFilter
- 解决post请求中乱码的问题
- 在SpringMVC框架，在web.xml注册过滤器，配置属性
配置字符集过滤器

@Configuration
public class WebApplicationConfig {
    @Bean
    public FilterRegistrationBean filterRegistrationBean(){
        FilterRegistrationBean bean = new FilterRegistrationBean();
        //使用框架中的过滤器类
        CharacterEncodingFilter filter = new CharacterEncodingFilter();
        filter.setEncoding("utf-8");
        filter.setForceEncoding(true);
        bean.setFilter(filter);
        bean.addUrlPatterns("/*");
        return bean;
    }
    @Bean
    public ServletRegistrationBean s(){
        ServletRegistrationBean bean = new ServletRegistrationBean(new SServlet(),"/sservlet");
        return bean;
    }
}

修改application.properties文件

#SpringBoot默认配置了CharacterEncodingDFilter，默认ISO-8859-1
server.servlet.encoding.enabled=false

也可以直接通过修改application.properties文件

server.servlet.encoding.enabled=true
server.servlet.encoding.charset=utf-8
#强制使用
server.servlet.encoding.force=true

4ORM操作MySQL

使用mybatis框架操作数据，在SpringBoot框架集成mybatis
步骤
- mybatis起步依赖：完成mybatis对象自动装配，对象放到容器中
- pom.xml指定src/main/java目录中的xml文件包含到classpath中
- 创建实体类Student
- 创建Dao接口StudentDao，创建方法
- 创建Dao接口对应的Mapper文件，xml文件，写sql语句
- 创建Service层对象，接口和其实现类，去dao对象的方法，完成数据库操作
- 创建Controller对象，访问Service
- 写application.properties文件
  - 配置数据库的连接信息

第一种方式@Mapper

@Mapper：放在dao接口的上面，每个接口都需要使用这个注解

/*
* @Mapper 告诉MyBatis这是dao接口，创建此接口的代理对象
* 位置：类上
* */

@Mapper
public interface StudentDao {
    Student selectById(@Param("stuId") Integer id);
}

第二种方式@MapperScan

/*
* @MapperScan 找到Dao接口和Mapper文件
* basePackages Dao接口所在包名
*/
@SpringBootApplication
@MapperScan(basePackages = "com.lyl.dao")

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

现在把Mapper文件放在resources目录下
- 在resources目录中创建子目录（自定义），如mapper
- 把mapper文件放到mapper目录下
- 在application.properties文件中，指定mapper文件的目录位置
```
mybatis.mapper-locations=classpath:mapper/**.xml
mybatis.configuration.log-impl=org.apache.ibatis.logging.stdout.StdOutImpl
```

第四种事务

spring框架中的事务
- 管理事务的对象：事务管理器（接口，接口有很多的实现类）
- 声明式事务：在xml配置文件或者使用注解说明事务控制的内容
  - 控制事务：隔离级别、传播行为、超时时间
- 事务处理方式
  - spring框架中的@Transactional
  - aspectj框架可以在xml配置文件中声明事务控制内容
springboot中使用事务
在业务方法的上面加入@Transactional，加入注解之后，方法有事务功能
明确的在主启动类的上面，加入@EnableTransactionManager

    /**
     * @Transactional 表示方法有事务支持
     *          默认：使用库的隔离级别，REQUIRED，传播行为，超时时间 -1
     */
    @Transactional
    @Override
    public int addStudent(Student student) {
        int rows = studentMapper.insert(student);
        System.out.println("执行sql...");
//      int m = 10/0;
        return rows;
    }

5接口架构风格-RESTful

接口：API
- 指访问servlet，controller的url，调用其他程序的函数
架构风格：api组织方式

5.1REST

RESTfule架构风格
- REST
  - Representational State Transfer
  - 表现层状态转移
  - 是一种接口的架构风格和设计理念，不是标准
  - 优点
    - 更简洁
    - 更有层次
- 要素
  - 用REST表示资源和对资源的操作。在互联网中，表示一个资源或者一个操作。
    - 资源使用url表示。
    - 资源用名词表示。
  - 对资源：
    - 查询资源
    - 创建资源
    - 更新资源
    - 删除资源
  - 使用http中的动作（请求），表示对资源的操作（CURD）
    - GET：查询资源
    - POST：创建资源
    - PUT：更新资源
    - DELETE：删除资源
- 一句话总结
  - 使用url表示资源，使用http动作操作资源。
注解
- @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.2在页面中或者ajax中，支持put、delete请求

在SpringMVC中有一个过滤器，支持post请求转为put，delete
过滤器：org.springframework.web.filter.HiddenHttpMethodFilter
作用
- 把请求中的post请求转为put，delete
步骤
- application.properties(yml)：开启HiddenHttpMethodFilter
- 在请求页面中，包含_method参数，它的值是put，delete，发起这个请求使用的post方式

6Redis

常用作缓存
Redis是一个中间件，是一个独立服务器。
java中著名的客户端：Jedis，lettuce，Redisson
Spring SpringBoot中有一个RedisTemplate（StringRedisTemplate），处理和redis交互

配置Window版本的Redis

为了节省开启linux占用内存问题
存在问题
- Redis闪退
- 解决方案
- https://blog.csdn.net/qq_939317133/article/details/126293072

<!--redis起步依赖-->
<dependency>
	<groupId>org.springframework.boot</groupId>
	<artifactId>spring-boot-starter-data-redis</artifactId>
</dependency>
data-redis使用的 lettuce客户端库
在程序中使用RedisTemplate类的方法操作redis数据，实际就是调用lettuce客户端中的方法

6.2对比StringRedisTemplate和RedisTemplate

StringRedisTemplate：把k，v都是作为String处理，使用的是String的序列化，可读性好
RedisTemplate：把k，v经过了序列化存到redis。k，v是序列化的内容，不能直接识别
- 默认jdk序列化

7SpringBoot继承Dubbo

7.1SpringBoot集成Dubbo的文档

https://github.com/apache/dubbo-spring-boot-project/blob/master/READEME_CN.md

7.2 公共项目

独立的maven项目：定义了接口和数据类

public class Student implements Serializable {
    private Integer id;
    private String name;
    private Integer age;
    }
public interface StudentService {
    Student queryStudent(Integer id);
}

7.3提供者

创建SpringBoot项目
pom.xml

<dependencies>
        <!--公共依赖项-->
        <dependency>
            <groupId>com.ggj</groupId>
            <artifactId>006-interface-api</artifactId>
            <version>1.0.0</version>
        </dependency>
        <!--dubbo-->
        <dependency>
            <groupId>org.apache.dubbo</groupId>
            <artifactId>dubbo-spring-boot-starter</artifactId>
            <version>2.7.8</version>
        </dependency>
        <!--zookeeper-->
        <dependency>
            <groupId>org.apache.dubbo</groupId>
            <artifactId>dubbo-dependencies-zookeeper</artifactId>
            <version>2.7.8</version>
            <type>pom</type>
            <exclusions>
                <exclusion>
                    <groupId>org.slf4j</groupId>
                    <artifactId>slf4j-log4j12</artifactId>
                </exclusion>
            </exclusions>
        </dependency>
    </dependencies>

实现接口

/**
 * 使用dubbo注解暴露服务
 */
@DubboService(interfaceClass = StudentService.class,version = "1.0",timeout = 5000)
public class StudentServiceImpl implements StudentService {

    @Override
    public Student queryStudent(Integer id) {
        Student student = new Student();
        if (1001==id) {
            student.setId(1001);
            student.setName("张三");
            student.setAge(16);
        }else if (1002==id){
            student.setId(1002);
            student.setName("李四");
            student.setAge(20);
        }
        return student;
    }
}

application.properties

#配置服务名称
spring.application.name=studentservice-provider
#配置扫描包，扫描@DubboService
dubbo.scan.base-packages=com.ggj.service
#配置dubbo协议
#dubbo.protocol.name=dubbo
#dubbo.protocol.port=20881

#注册中心
dubbo.registry.address=zookeeper://localhost:2181

启动类上面

/**
 * @EnableDubbo 启用dubbo配置
 * @EnableDubboConfig
 * @DubboComponentScan
 */
@SpringBootApplication
@EnableDubbo
public class ProviderApplication {

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

}

7.4消费者

pom.xml

<dependencies>
        <!--公共依赖项-->
        <dependency>
            <groupId>com.ggj</groupId>
            <artifactId>006-interface-api</artifactId>
            <version>1.0.0</version>
        </dependency>
        <!--dubbo-->
        <dependency>
            <groupId>org.apache.dubbo</groupId>
            <artifactId>dubbo-spring-boot-starter</artifactId>
            <version>2.7.8</version>
        </dependency>
        <!--zookeeper-->
        <dependency>
            <groupId>org.apache.dubbo</groupId>
            <artifactId>dubbo-dependencies-zookeeper</artifactId>
            <version>2.7.8</version>
            <type>pom</type>
            <exclusions>
                <exclusion>
                    <groupId>org.slf4j</groupId>
                    <artifactId>slf4j-log4j12</artifactId>
                </exclusion>
            </exclusions>
        </dependency>
    </dependencies>

创建了Controller或者Service都可以

@RestController
public class DubboController {
    /**
     * 引用远程服务，把创建好的服务，注入给studentService
     */
    @DubboReference(interfaceClass = StudentService.class,version = "1.0")
    private StudentService studentService;
    @GetMapping("/query")
    public String queryStudent(){
        Student queryStudent = studentService.queryStudent(1001);
        return "调用远程接口，获取对象"+queryStudent;
    }
}

application.properties

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

8总结

8.1注解

Spring+SpringMVC+SpringBoot

创建对象：
@Controller：放在类上，创建控制器对象，注入容器中
@RestController：类上，创建控制器对象，注入容器中
				作用：复合注解是@Controller，@ResponseBody，使用这个注解类的，里面的控制器方法的返回值都是数据
@Service：业务层实现类上面，创建Service对象，注入容器
@Repository：放到dao层的实现类上，创建dao对象，放入到容器，因为现在大都是使用MyBatis框架，dao对象都是MyBatis通过代理生成的，不需要@Repository。
@Component：放在类上面，创建此类对象，放入到容器中。

赋值：
@Value：简单类型的赋值
		还可以获取文件的数据（properties或yml）
		@Value("${server.port}") private Integer port
@Autowired：引用类型赋值自动注入，支持byName，byType，默认byType。放在属性上，也可以放在构造方法上，推荐后者。
@Qualifer：给引用类型赋值，使用byName
@Autowired，@Qualifer：spring框架提供
@Resource：来自于jdk，javax.annotation，实现引用类型的自动注入，支持byName，byType，默认byName。如果默认失败，在使用byType注入。在属性上使用

其他：
@Configuration：放在类上面，表示只是个配置类，相当于xml配置文件
@Bean：放在方法的上面，把方法的返回值对象，注入到spring容器中
@ImportResource：加载其他的xml配置文件，把文件中的对象注入到spring容器中
@PropertySource：读取其他的properties属性配置文件
@ComponentScan：扫描器，指定包名，扫描注解的
@ResponseBody：方法上，表示方法的返回值是数据，不是视图
@RequestBody：把请求体中的数据，读取出来，转为java对象使用
@ControllerAdvice：控制器增强，放在类上面，表示此类提供了方法。可以对controller增强功能
@ExceptionHandler：处理异常，放在方法上
@Transcational：处理事务，放在service实现类的public方法上，表示此方法有事务

SpringBoot中使用的注解
@SpringBootApplication：放在启动类上，包含了@SpringBootConfiguration、@EnableAutoConfiguration、@ComponentScan

MyBatis相关的注解
@Mapper：放在类上，让MyBatis找到接口，创建代理对象
@MapperScan：放在主类上，指定扫描的包，把这个包中的所有接口都创建代理对象，注入到容器中
@Param：放在dao接口的方法的形参前，作为命名参数使用

Dubbo注解
@DubboService：提供者端使用，暴露服务，放在接口的实现类上
@DubboReference：消费者端使用，引用远程服务。放在属性上面使用
@EnableDubbo：放在主类上，表示当前引用启动Dubbo功能