zoukankan      html  css  js  c++  java

  • SpringBoot入门一：基础知识（环境搭建、注解说明、创建对象方法、注入方式、集成jsp/Thymeleaf、logback日志、全局热部署、文件上传/下载、拦截器、自动配置原理等）

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

    SpringBoot（微框架）=SpringMVC（控制器）+Spring（项目管理）

    特点：

    （1）创建独立的Spring应用程序

    （2）嵌入的Tomcat，无需部署WAR文件

    （3）简化Maven配置

    （4）自动配置Spring

    （5）没有XML配置

    一、搭建第一个SpringBoot环境

    1、开发步骤（手动）

    创建一个maven项目

    1）引入依赖

    spring-boot-starter-parent：继承springboot的父项目

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

    spring-boot-starter-web：引入web支持

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

    2）引入springboot的配置文件：resources/application.properties或者resources/application.yaml

    3）开发springboot入口类：com.icucoder.learn.LearnApplication.class(必须在父包中)

    4）开发Controller测试：（同springmvc）

    注意：如果要使用jsp文件，则需要在java和resources同级目录新建webapp目录。

    2、开发步骤（自动）

    使用intellijidea开发工具，新建一个Spring Initializr项目，然后开发Controller测试。

    二、springboot中配置文件拆分

    在实际开发过程中生成环境和测试环境有可能是不一样的，因此将生产环境中的配置和测试环境中的配置拆分是必要的。将公共配置放入主配置文件中，将不同配置放入不同环境配置文件中。在主配置文件中使用：spring.profiles.active=dev激活不同环境的配置文件。

    主：application.properties

    开发：application-dev.properties

    生产：application-prod.properties

    三、springboot中工厂特性创建对象

    1、java config方式自定义java对象管理

    1）创建单个自定义对象

    @Component：通用组件对象的创建注解

    　　@Service：标识业务层组件创建

    　　@Controller：控制器对象创建

    　　@Repository：用来创建DAO组件注解

    以上一般用于自定义的类的对象的创建。

    2）一次性创建多个组件对象（包含复杂对象）:@Configuration

    @Configuration是配置注解（也是派生注解），修饰范围：用在类上，相当于曾经的spring.xml。springboot会把该类中每一个方法（方法上需要加上@Bean标签，用来创建这个对象在工厂中一个实例，默认是单例）当做一个对象的创建。

    @Configuration
public class BeansConfig {
    
    @Bean
    public Calendar getCalendar() {
        return Calendar.getInstance();
    }
}

     一般用于框架提供的类的对象的创建。

    3）在使用时使用@Import导入指定对象

    @RestController
@RequestMapping("/learn")
@Import(Company.class)//有一个实体类Company
public class LearnController {

    @Autowired
    Company company;

    @RequestMapping("test")
    public String test() {
        System.out.println("company:" + company);
        return "user test1";
    }
}

    2、xml方式配置：通过xml配置管理java对象

    新建一个spring的xml，如spring.xml，使用<bean/>标签，然后再启动类上加上@ImportResource("spring.xml")

    四、springboot中注入方式

    1、属性注入

    使用@Value注解进行属性注入

    1）在配置文件中定义变量:

    #application.properties中定义变量
users=mayun

     2）然后再Controller中使用@Value进行注入:

    @RestController
@RequestMapping("/learn")
public class LearnController {
    @Value("${names}")
    private String name;

    @RequestMapping("test")
    public String test() {
        return name;
    }
}

     　　注入基本类型：String、日期类型、八种基本类型使用@Value形式注入

    2、对象注入

    使用@ConfigurationProperties注解进行对象注入

    1）在配置文件中定义对象：

    #application.properties中定义对象
user.id=7
user.name=mayun
user.age=19
user.email=admin@qq.com

     2）编写一个基本类User，使用@ConfigurationProperties进行注入：

    @Component
@ConfigurationProperties(prefix = "user")
public class User {
    private Integer id;
    private String name;
    private Integer age;
    private String email;
    //略去构造方法和setter/getter方法   
}

     3）然后再Controller中使用:

    @RestController
@RequestMapping("/learn")
public class LearnController {
    @Autowired
    private User user;

    @RequestMapping("test")
    public User test() {
        return user;
    }
}

    　　在基本类上不使用@ConfigurationProperties，而在基本类中的每个成员变量上可以使用@Value进行注入，但是比较麻烦。

    　　可以使用构建源数据来在配置文件中智能提示属性：

    <!--自定义注入时构建元数据-->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-configuration-processor</artifactId>
</dependency>

    3、自动注入

    1）@Autowired

    2）@Resource

    五、springboot中集成jsp页面模板

    默认推荐视图模板为Thymelaf，类似于freemarker。

    1、与jsp集成步骤

    1）引入依赖（springboot依赖略）

    <!--jstl 和 配置内嵌tomcat解析jsp-->
    <dependency>
    <groupId>javax.servlet</groupId>
    <artifactId>jstl</artifactId>
</dependency>
<dependency>
    <groupId>org.apache.tomcat.embed</groupId>
    <artifactId>tomcat-embed-jasper</artifactId>
</dependency>

    2）配置jsp运行插件

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

    3）在application.properties中配置视图解析的前缀和后缀

    spring.mvc.view.prefix=/
spring.mvc.view.suffix=.jsp

    4）配置启动的working directory为ModuleFileDir（此为idea缺陷，新版本好像不需要设置了）

    5）在与java和resources同级目录新建webapp目录，并新建一个file.jsp文件：

    6）编写Controller进行测试：http://127.0.0.1:8090/learn/test

    @Controller
@RequestMapping("/learn")
public class LearnController {

    @RequestMapping("test")
    public String test() {
        return "file";
    }
}

    2、jsp页面热部署

    热部署：在不需要重启服务器情况下将jsp页面修改立即生效的过程

    在springboot中默认jsp页面部署方式使用的是生产模式部署，修改之后必须重启服务器才能生效。

    使用下述配置可以改为jsp热部署：

    #jsp页面热部署
server.servlet.jsp.init-parameters.development=true

    六、springboot中集成Thymeleaf页面模板

    　　Thymeleaf是一个用于web和独立环境的现代服务器端Java模板引擎。它是跟Velocity、FreeMarker类似的模板引擎，它可以完全替代JSP，相较与其他模板引擎，Thymeleaf在有网络和无网络的环境下皆可运行。即它可以让美工在浏览器查看页面的静态效果，也可以让程序员在服务器查看带数据的动态页面效果。

    1、与Thymeleaf集成步骤

    1）引入依赖（springboot依赖略）

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

     2）在application.yaml进行属性配置

    #使用模板目录
spring.thymeleaf.prefix=classpath:/templates/
#使用模板后缀
spring.thymeleaf.suffix=.html
#使用模板编码
spring.thymeleaf.encoding=UTF-8
#开始thymeleaf模板
spring.thymeleaf.enabled=true
#使用模板响应类型
spring.thymeleaf.servlet.content-type=text/html

     3）在与java和resources子目录新建templates目录，并新建一个index.html文件：

    注意：templates目录必须经过控制器才能访问，而static则不需要

    （1）html中加入thymeleaf命令空间

    <html lang="en" xmlns:th="http://www.thymeleaf.org">

     

     4）编写Controller进行测试：http://127.0.0.1:8090/learn/test

    @Controller
@RequestMapping("/main")
public class MainController {
    @RequestMapping("/")
    public String index(){
        return "index";
    }
}

     2、Thymeleaf语法入门

    七、springboot集成logback日志展示

    1、基本概念

    logback是log4j创始人设计的又一个开源日志组件。轻量级、易用。

    1）日志级别（级别越低输出日志信息越多）：ALL<DEBUG<INFO<WARN<ERROR<OFF

    2）项目中日志分类：

    （1）项目根日志（rootLogger）：全局日志，一个项目只有一个根日志。

    （2）项目中子日志（logger）：包级别日志，一个项目中可以有n多个子日志。

    2、日志配置

    注意：springboot框架中默认根日志为INFO

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

    1）自动引入日志相关包

    private static final Logger log=LoggerFactory.getLogger(UserService.class);

     2）使用插件包

    插件包配置如下，然后输入logd或者logi会自动引入日志相关包

    八、springboot开启全局热部署

    原理：开启两个类加载器ClassLoader，修改后进行类加载器的切换

    1、官方提供的两种方式

    1）springboot-devtools

    （1）引入依赖

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

    （2）开启idea自动编译功能

     （3）开启idea中允许在程序运行过程中运行交换类加载器

    ctrl+alt+shift+/

    （4）重启服务器，有restartMain即有效

    2）spring-loaded

    3）JRebel（第三方）

    九、springboot中切面编程

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

    1、引入依赖

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

    2、相关注解

    @Aspect 用在类上，代表这个类是一个切面

    @Before用在方法上，代表这个方法是一个前置通知方法

    @After用在方法上，代表这个方法是一个后置通知方法

    @Around用在方法上，代表这个方法是一个环绕方法

    1）前置和后置通知使用

    前置通知和后置通知都没有返回值，方法参数都为joinpoint。

    2）环绕通知使用

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

    3）切入点表达式种类

    （1）execution方法级别

    （2）within类级别

    （3）@annotation基于注解的切入点表达式

    十、springboot中文件上传

     文件上传指的就是将用户本地计算机中文件通过网络的形式上传到服务器上的过程。

    1、springboot中开发文件上传功能

    1）开发一个可以进行文件上传的页面（这里如果采用前后端分离的项目则不需要）

    　　其中form表单提交方式必须为post，form的enctype属性等于application/x-www-form-urlencoded表示文本，等于multipart/form-data表示二进制。

    <%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %>
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>文件</title>
</head>
<body>
<h3>文件上传</h3>
<form action="${pageContext.request.contextPath}/file/upload" method="post" enctype="multipart/form-data">
    <input type="file" name="file"/>
    <input type="submit" value="开始上传">
</form>
</body>
</html>

    2）开发Controller，其方法的使用MultipartFile来接收文件，并放入指定的目录

    @Controller
@RequestMapping("/file")
public class FileController {
    @RequestMapping("/")
    public String index() {
        return "file";
    }

    @RequestMapping("/upload")
    public String upload(MultipartFile file, HttpServletRequest request) throws IOException {
        String realPath = request.getSession().getServletContext().getRealPath("/file");
        System.out.println(realPath);
        file.transferTo(new File(realPath, file.getOriginalFilename()));
        return "redirect:/file.jsp";
    }
}

     注意：文件上传其他细节处理基本同SpringMVC

     文件上传大小限制：

    #文件上传大小限制配置 bytes
spring.servlet.multipart.max-file-size=10240

    十一、springboot中文件下载

     用户将服务器中文件下载到自己本地计算机中过程称之为文件下载。

    1、springboot中开发文件下载功能

    1）定位哪些文件可以被文件下载

    2）将需要下载文件放入指定下载目录中

    3）开发一个页面提供文件下载链接（一个请求只能对应一个响应，处理文件下载时方法不能有返回（即跳转页面，因为跳转页面也是一次响应），因为下载是文件响应流）

    <%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %>
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>文件</title>
</head>
<body>
<h3>文件下载</h3>
<a href="${pageContext.request.contextPath}/file/download?fileName=init">下载</a>
</body>
</html>
     4）开发下载的Controller
    @Controller
@RequestMapping("/file")
public class FileController {
    @RequestMapping("/")
    public String index() {
        return "file";
    }

    @RequestMapping("/download")
    public String download(String fileName, HttpServletRequest request, HttpServletResponse response) throws IOException {
        //String realPath = request.getSession().getServletContext().getRealPath("/file");//servlet-api 2.5规范
        String realPath = request.getServletContext().getRealPath("/file");//3.0+规范
        System.out.println(realPath);
        //通过文件输入流读取文件
        FileInputStream is = new FileInputStream(new File(realPath, fileName));//文件内容字符编码处理
        response.setContentType("text/plain;charset=UTF-8");
        //获取响应输出流
        ServletOutputStream os = response.getOutputStream();
        //附件形式下载 attachment 附件，inline 在线打开
        response.setHeader("content-disposition", "attachment;fileName=" + fileName);
        //处理下载流复制-使用工具类
        IOUtils.copy(is, os);
        IOUtils.closeQuietly(is);
        IOUtils.closeQuietly(os);
        return "redirect:/file.jsp";
    }
}

    十二、拦截器

    类似于javaweb中的Filter，用来对请求进行拦截，可以将多个Controller中执行的共同代码放入拦截器中执行，减少Controller类中代码的冗余。

    特点：拦截器只能拦截控制器的相关请求，不能拦截静态资源和页面的相关请求；请求发送经过拦截器，请求响应也经过拦截器；拦截器可以中断用户的请求；拦截器可以针对性的拦截某些控制器的请求。

    1、springboot1.x开发拦截器步骤

    1）实现HandlerInterceptor接口，并实现接口中的方法

    　　请求经过拦截器会优先进入拦截器中的preHandle方法，执行preHandle方法中的内容；如果preHandle返回为true，代码放行请求（会执行当前请求对应的控制器中的方法，当控制器中的方法执行结束之后，会返回拦截器中，并执行拦截器中postHandle方法，postHandle执行完成之后，会响应请求，同时在响应请求完成后会执行afterCompletion方法），如果返回false，则中断请求。

    public class MyInterceptor implements HandlerInterceptor {
    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        return false;
    }

    @Override
    public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView) throws Exception {

    }

    @Override
    public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception {

    }
}

     2）新建配置类，继承WebMvcConfigurerAdapter （已过时），配置拦截器。

    2、springboot2.x开发拦截器步骤

    1）实现HandlerInterceptor接口，并实现接口中的方法

    　　请求经过拦截器会优先进入拦截器中的preHandle方法，执行preHandle方法中的内容；如果preHandle返回为true，代码放行请求（会执行当前请求对应的控制器中的方法，当控制器中的方法执行结束之后，会返回拦截器中，并执行拦截器中postHandle方法，postHandle执行完成之后，会响应请求，同时在响应请求完成后会执行afterCompletion方法），如果返回false，则中断请求。

    2）新建配置类实现WebMvcConfigurer的方法addInterceptors并加@Configuration注解。

    @Configuration
public class MyInterceptorConfig implements WebMvcConfigurer {
    @Override
    public void addInterceptors(InterceptorRegistry registry) {
        //拦截所有：/**；排除指定拦截：/code/**
        registry.addInterceptor(new MyInterceptor()).addPathPatterns("/**").excludePathPatterns("/code/**");
    }
}
 

    3）多个拦截器的执行顺序。

    拦截器栈：

    十三、自动配置原理

    十四、部署方式（war|jar）

    1、war

    一旦使用war包部署，application.yml中配置的port，context-path就失效了，访问时使用打成war包的名字和外包tomcat端口号进行访问项目。
    1）修改pom.xml的packaging为war
    <packaging>war</packaging>

     2）在插件中指定入口类的位置

    <plugins>
	<plugin>
		<groupId>org.springframework.boot</groupId>
		<artifactId>spring-boot-maven-plugin</artifactId>
		<!--使用热部署出现中文乱码解决方案-->
		<configuration>
			<fork>true</fork>
			<!--增加jvm参数-->
			<jvmArguments>Dfile.encoding=UTF-8</jvmArguments>
			<!--指定入口类-->
                       <mainClass>com.icucoder.thymeleaf.ThymeleafApplication</mainClass>
		</configuration>
	</plugin>
	<!--在这里修改版本-->
	<plugin>
		<groupId>org.apache.maven.plugins</groupId>
		<artifactId>maven-resources-plugin</artifactId>
		<version>2.4.3</version>
	</plugin>
</plugins>

     3）排除内嵌的tomcat

    <dependency>
	<groupId>org.springframework.boot</groupId>
	<artifactId>spring-boot-starter-tomcat</artifactId>
	<scope>provided</scope><!--排除内嵌的tomcat-->
</dependency>
<dependency>
	<groupId>org.apache.tomcat.embed</groupId>
	<artifactId>tomcat-embed-jasper</artifactId>
	<scope>provided</scope><!--去掉使用内嵌tomcat解析jsp，如果使用thymeaf则不需要-->
</dependency>

     4）配置入口类

    //继承SpringBootServletInitializer,然后覆盖configure方法
@SpringBootApplication
public class ThymeleafApplication extends SpringBootServletInitializer {

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

    protected SpringApplicationBuilder configure(SpringApplicationBuilder builder) {
        return builder.sources(ThymeleafApplication.class);
    }
}

    2、jar

     1）修改pom.xml的packaging为jar
     或者默认
     2）如果使用jar包部署，并且有文件上传/下载，则需要将目录映射到jar以外的目录。
    配置文件application.properties中定义目录变量，然后在代码中使用@Value注解获得变量的值。
    注意：
     
     
     
     
     
     
     

    如果你真心觉得文章写得不错，而且对你有所帮助，那就不妨小小打赏一下吧，如果囊中羞涩，不妨帮忙“推荐"一下，您的“推荐”和”打赏“将是我最大的写作动力！

    本文版权归作者所有，欢迎转载，但未经作者同意必须保留此段声明，且在文章页面明显位置给出原文连接.
    qq群 微信
  • 相关阅读:
    linux系统root用户忘记密码的重置方法
    Linux系统的初始化配置
    LINUX awk 函数
    随机产生一个密码，要求同时包含大小写以及数字这三种字符。
    sed 函数 linux
    grep 函数
    linux sort 函数
    从零开始的JAVA -4. 运算符与表达式
    cp
    PATH
  • 原文地址：https://www.cnblogs.com/hoaprox/p/14584326.html
Copyright © 2011-2022 走看看