SpringBoot

Posted 2020-12-16 ltppp

为什么使用？

简化Spring框架开发的应用框架，主要用来简化繁琐的配置，让我们快速搭建基于spring框架的应用项目，

SpringBoot特性

1. springboot遵循“习惯优于配置”的理念，帮助开发者快速搭建spring框架
2. 内嵌式容器，无需部署war文件
3. 简化maven配置（只需要配置相关启动器即可）
4. 提供就绪功能，如监控性能模式，健康检查功能。
   

开发步骤

1. 创建Springboot initailizer项目
2. 再创建过程中勾选相关的启动器

项目结构

src/main/java：源文件夹
src/main/resources：存放配置文件及静态资源的目录
static
templates
application.properties
src/test：测试代码目录

常用配置

server.port 端口
server.servlet.context-path 上下文路径
spring.mvc.date-format 提交请求数据的日期格式
spring.jackson.date-format 相应json数据的日期格式
spring.thymeleaf.cache true 模板页面缓存
spring.jsckson.time-zone 配置时区

常用配置如下图所示

springboo配置文件

1. Spring boot 支持两种格式的配置文件
   • 属性文件:applicaiton.properties
   • yaml文件:application.yml
2. yaml 是一种简洁的非标记语言。Yaml以数据为中心，使用空白，缩进，分行组织数据，从而使得表示更加简洁易读。
3. Spring boot可以根据不同的环境提供不同的profile文件
   • profile文件的命名格式为application-{env}.yml
   • 通过spring.profiles.active配置选项来指定不同的profile

自定义配置

除了Spring boot内置的配置外，根据项目扩展性的需要，可以进行自定义配置项。Spring boot中，有两种方式使用自定义配置项。
方式一：@Value 单个属性注入

• 创建建config.properties文件
• 配置启动类加载配置文件： @PropertySource(“classpath: config.properties”)
• 程序中使用 @Value注入值： @Value(${配置文件中的key}）
  方式二：@ConfigurationProperties类型安全加载
• 可以将配置文件中的属性自动赋值给类中的属性
• 使用@ConfigurationProperties（prefix=“key的前缀”）

项目依赖及启动

1. 所有springboot项目的pom依赖都必须继承，spring-boot-starter-parent 父启动器
2. 启动类上必须添加@springbootApplication注解，通过tomcat启动内嵌tomcat容器
3. 所有业务接口 ，控制器实现等全部都要创建再启动类的同包或者是其子包中。

SpringBoot基础配置详解

1. 在resources中创建application.yml文件

#指定项目源地址
server:
  servlet:
    context-path: /spring
spring:
  mvc:
    #提交请求数据的日期格式
    date-format: yyyy-MM-dd
    #响应json数据的日期格式
  jackson:
    date-format: yyyy-MM-dd
    time-zone: GMT+8
  profiles:
    #指定使用的配置文件
    active: dev
#配置pagehelper
pagehelper:
  helper-dialect: mysql
  support-methods-arguments: true
  params: pageNum=pageIndex,pageSize=pageSize
#日志的简单用法
#logging:
#  level:
#    root: error
#    com.woniu.springboot01.dao: debug

2. 在resources中创建application-dev.yml文件

#配置端口
server:
  port: 8080
#配置数据源
spring:
  datasource:
    driver-class-name: com.mysql.jdbc.Driver
    url: jdbc:mysql://localhost:3306/oasystem?serverTimezone=GMT%2b8
    username: root
    password: 123
#配置mybatis映射文件地址
mybatis:
  mapper-locations: classpath:mapper/*.xml
  

如何在程序中获取properties的信息

我们在resources文件夹中创建了一个properties文件。如下图所示：

获取他有两种方式,当然首先我们需要在启动文件中，加载config文件：
//加载config文件
@PropertySource(value = "classpath:config.properties")

1. 通过@Value注解获取
   @Value("${resource.path}")
   private String path;
2. 通过实体类获取
   当参数多了，需要反复使用注解，很不方便，于是我们便可以通过实体类来获取。需要注意的是我们要使用统一的前缀。比如上图中的app.

//标记这个类，将这个类撞到spring工厂中
@Component
@ConfigurationProperties(prefix = "app")
public class AppInfo {
    private String title;
    private String content;

    public String getTitle() {
        return title;
    }

    public void setTitle(String title) {
        this.title = title;
    }

    public String getContent() {
        return content;
    }

    public void setContent(String content) {
        this.content = content;
    }
}

这样，在controller中通过autowired加载这个类，就可以获得了。

如何在SpringBoot中整合Mybatis

1. 配置mybatis-spring-boot-starter启动器依赖
2. 在启动类中添加注解，扫描DAO接口的包
   @MapperScanner(value={"","",""})
3. 在application.yml配置：
   • 数据源 dataSource
   • 配置加载sql映射文件的路径:mapperLocations: classpath:

如何在SpringBoot中使用PageHelper插件

1. 添加pagehelper启动器

<dependency>
            <groupId>com.github.pagehelper</groupId>
            <artifactId>pagehelper-spring-boot-starter</artifactId>
            <version>1.2.3</version>
</dependency>

2. 配置支持参数分页

pagehelper:
              helper-dialect: mysql
              support-methods-arguments: true
              params: pageNum=currentPage,pageSize=pageSize

3. 在查询的方法中使用 @Param注解

springBoot单元测试

1. 配置依赖：spring-boot-starter-test
2. 单元测试注解：
   • @RunWith(SpringRunner.class)
   • @SpringBootTest

springboot使用jsp

1. 配置依赖

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

2. 在配置文件中配置springmvc的视图为jsp
   • spring.mvc.view.prefix=/
   • spring.mvc.view.suffix=.jsp
3. 在src/main下创建webapp目录，添加web.xml.然后在该目录下创建jsp文件：webapp-->WEB-INF--->web.xml

如何在SpringBoot中使用logback日志

spring已经默认添加了logback包，只需要添加配置，或者导入配置文件即可

logger:
level:
root: 全局的日志级别
包名: 级别
如果需要更详细的日志信息，需要定义日志文件：

SpringBoot中默认采用logback作为日志工具：
1)配置logback.xml
2)如果在Springboot项目进行日志环境的切换需要提供logback-spring.xml的配置文件；来定义不同环境的日志信息。

Thymeleaf模板引擎

什么是模板引擎

是为了使用户界面与业务数据（内容）分离而产生的，它可以生成特定格式的文档，
用于网站的模板引擎就会生成一个标准的html文档。

Thymeleaf表达式

1. 标准变量表达式
   A. ${} 获取上下文，Model中的数据
   B. #{} 获取静态数据
2. 选择变量表达式
   A. *{} 使用th:object属性来绑定对象，获取对象属性。
3. URL表达式
   A. @{} 用于定义URL
   B. 可以在其中嵌套 ${}表达式
   • < a th:href="@{‘/edit/‘+${emp.empno}}">edit< /a>
   • < a th:href="@{|/hello/${emp.empno}|}">edit< /a>

示例：

SpringBoot使用过滤器

1. 开发过滤器，实现Filter接口，注意不使用组件实例化（@Component）。为了防止拦截器失效。

public class AuthFilter implements Filter {

    @Override
    public void doFilter(ServletRequest servletRequest, ServletResponse servletResponse, FilterChain filterChain) throws IOException, ServletException {
        HttpServletRequest request= (HttpServletRequest) servletRequest;
        //获取session，强转
        HttpSession session=request.getSession();
        HttpServletResponse response= (HttpServletResponse) servletResponse;
        //获取请求路径
        String url=request.getRequestURI();
        System.out.println("执行过滤器");
        if(url.endsWith("login") ||
                url.endsWith("doLogin") ||
                url.endsWith(".css") ||
                url.endsWith(".js") ||
                url.endsWith(".png") ||
                url.endsWith(".jpg")){
            filterChain.doFilter(servletRequest,servletResponse);
            return;
        }
        User user= (User) session.getAttribute(SystemConstant.CURRENT_USER);
        if(user == null){
            response.sendRedirect("/login");
            return;
        }
        filterChain.doFilter(servletRequest,servletResponse);


    }
}

2. 在springboot中进行注册

//注册过滤器
    @Bean
    public FilterRegistrationBean registrationBean(){
        FilterRegistrationBean bean=new FilterRegistrationBean();
        bean.setFilter(new AuthFilter());//注册过滤器
        bean.addUrlPatterns("/*");
        bean.setOrder(1);
        return bean;
    }

SpringBoot中使用拦截器

1. 开发拦截器，实现HandlerInterceptor接口，要进行组件实例化@component

//开发拦截器
@Component
public class AuthInterceptor implements HandlerInterceptor {
    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        System.out.println("执行拦截器");
        HttpSession session = request.getSession();
        User user = (User) session.getAttribute(SystemConstant.CURRENT_USER);
        if(user == null){
            response.sendRedirect("/login");
            return false;
        }
        return true;
    }
}

2. 注册拦截器，在配置类中进行注册,需要重写addinterceptors方法。

@Autowired
   private AuthInterceptor authInterceptor;

   //注册拦截器，重写addinterceptors方法
    @Override
    public void addInterceptors(InterceptorRegistry registry) {
        registry.addInterceptor(authInterceptor).addPathPatterns("/*").
                excludePathPatterns("/login","/dologin");//添加authInterceptor拦截器，除login，dolgin不拦截。
    }

SpringBoot使用druid连接池

1. 在pom文件配置依赖

<!--德鲁伊连接池的启动器-->
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>druid-spring-boot-starter</artifactId>
            <version>1.1.18</version>
        </dependency>

2. 在配置文件中进行相关配置

spring.datasource.type=com.alibaba.druid.pool.DruidDataSource
spring.datasource.druid.max-active=20
spring.datasource.druid.max-wait=10000
#归还连接时校验有效性，推荐关闭
spring.datasource.druid.test-on-return=false
#使用中是否校验有效性，推荐关闭
spring.datasource.druid.test-on-borrow=false
#空闲时校验，建议开启
spring.datasource.druid.test-while-idle=true
#设置过滤器，stat用于接收状态，wall用于防止SQL注入,logback则说明使用logback日志输出
spring.datasource.druid.filters=stat,wall,logback
#统计所有数据源状态
spring.datasource.druid.use-global-data-source-stat=true
#sql合并统计，与设置慢SQL时间为500毫秒
spring.datasource.druid.connection-properties=druid.stat.mergeSql=true;druid.stat.slowSqlMillis=500

3. 在配置类中注册druid提供的过滤器和Servlet。

//使用德鲁伊的sql监控
    //注册德鲁伊过滤器
    @Bean
    public FilterRegistrationBean registrationBean(){
        FilterRegistrationBean bean = new FilterRegistrationBean();
        WebStatFilter filter=new WebStatFilter();
        bean.setFilter(filter);
        bean.addUrlPatterns("/*");
        return bean;
    }
    //注册StatViewServlet:用来展示视图
    @Bean
    public ServletRegistrationBean servletRegistrationBean(){
        //以/druid/请求的路径全部经过该servlet
        ServletRegistrationBean bean=new ServletRegistrationBean(new StatViewServlet(),"/druid/*");
        Map init=new HashMap();
        init.put("loginUsername","hello");
        init.put("loginPassword","123");
        bean.setInitParameters(init);
        return bean;
    }

SpringBoot的声明式事务的使用

1. 在启动类中开启：@EnableTransactional

@SpringBootApplication
@MapperScan(value = {"com.woniu.rbacsystem.dao"})
@EnableTransactionManagement//开启事务管理器
public class RbacsystemApplication  {

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

2. 在业务类中通过注解进行事务管理

@Service
//必须开启事务，没开启就开启，默认隔离识别：不能脏读。
//声明式事务默认只会对runtimeexception（运行时异常）进行回滚，对exception（检查异常）
//如果不像让某个运行时异常不回滚，例如算术异常，@Transactional（noRoolbackForClassName = "ArithmeticException.class"）
//对于查询方法，我们开启只读事务即可，优化性能。@Transactional（readOnly = true）
@Transactional(propagation = Propagation.REQUIRED,isolation = Isolation.DEFAULT)
public class AuthServiceImpl implements AuthService {
    @Autowired
    AuthMapper authMapper;

    @Override
    public List<Auth> findAuthsByUserId(int userId, int parentId) {
        return authMapper.findAuthByUserId(userId,parentId);
    }
    //查询所有权限
    @Override
    public List<Auth> findAllAuth() {
        return authMapper.findAllAuth();
    }

    @Override
    public Auth findAuthByName(String authName) {
        return authMapper.selectAuthByName(authName);
    }

    @Override
    public void updateAuth(Auth auth) {
        authMapper.updateByPrimaryKeySelective(auth);
    }
}

SpringBoot打包

打jar包方式

1. 在pom文件中的中添加：jar
2. maven ---> package
3. 进入项目的target文件夹中，可以看到已经生成了jar文件。此时可以按住shift加鼠标右键，打开命令管理行，然后输入java -jar xxx.jar即可。
4. 如果要修改端口等信息，直接在同级别目录下，放入***.yml配置文件。

打war包方式

1. 启动类要继承 SpringBootServletInitializer。然后实现config方法

public class RbacsystemApplication extends SpringBootServletInitializer {

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

	//打war包
    @Override
    protected SpringApplicationBuilder configure(SpringApplicationBuilder builder) {
        //写上这个类的类名
        return builder.sources(RbacsystemApplication.class);
    }
}

2. pom.xml添加---> war
3. 添加tomcat依赖

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

4. maven--->packag