springboot搭建解析

最新推荐文章于 2024-06-03 15:19:51 发布

清风明月_vip

最新推荐文章于 2024-06-03 15:19:51 发布

阅读量495

点赞数

分类专栏： springcloud 文章标签： java

本文链接：https://blog.csdn.net/huanglitai/article/details/118336873

版权

springcloud 专栏收录该内容

2 篇文章 0 订阅

订阅专栏

1.1.什么是SpringBoot

SpringBoot是Spring项目中的一个子工程，与我们所熟知的Spring-framework 同属于spring的产品:

用一些固定的方式来构建生产级别的spring应用。Spring Boot 推崇约定大于配置的方式以便于你能够尽可能快速的启动并运行程序。

1.2.为什么要学习SpringBoot

java的开发框架设计模式还是比较麻烦的，各种配置，xml，等

复杂的配置，

项目各种配置繁琐，导致开发效率不高，xml较多，每个技术都要交由spring管理，增加额外的xml文件
依赖混乱不透明。

项目中一般都会引入大量的依赖，因为技术比较多，当引入技术比较多了，还需要考虑技术的版本是否与spring对应，与其他技术间是否冲突，如果出现了依赖版本冲突，解决起来非常麻烦，项目之间技术的兼容性是一个棘手的事情
而SpringBoot解决了，繁琐配置，以及依赖混乱的局面

Spring Boot 简化了基于Spring的应用开发，只需要“run”就能创建一个独立的、生产级别的Spring应用。Spring Boot为Spring平台及第三方库提供开箱即用的设置（提供默认设置，存放默认配置的包就是启动器），这样我们就可以简单的开始。多数Spring Boot应用只需要很少的Spring配置。

我们可以使用SpringBoot创建java应用，并使用java –jar 启动它，就能得到一个生产级别的web工程。

1.3.SpringBoot的特点

Spring Boot 主要目标是：

为所有 Spring 的开发者提供一个非常快速的、广泛接受的入门体验
开箱即用（启动器starter-其实就是SpringBoot提供的一个jar包），但通过自己设置参数（.properties/yml），即可快速摆脱这种方式。
提供了一些大型项目中常见的非功能性特性，如内嵌服务器、安全、指标，健康检测、外部化配置等
绝对没有代码生成，也无需 XML 配置。

还有很多其他功能

2.快速入门

接下来讲解SpringBoot搭建一个web工程

2.1.创建工程

我们先新建一个空的工程：

new--》project

选择maven直接继续，不用选类型

工程名为demo：

然后填写项目名称和组id 版本等信息：

目录结构

项目结构：

2.2.添加依赖

现在项目与SpringBoot还没有什么关联。SpringBoot提供了一个名为spring-boot-starter-parent的工程，里面继承了spring-boot-dependencies 这个项目中，已经对各种常用依赖的版本进行了管理，我们的项目需要以这个项目为父工程，这样我们就不用操心依赖的版本问题了，需要什么依赖，直接引入坐标即可，只要规定springboot版本，其他技术跟会自动跟boot匹配的版本依赖

2.2.1.添加父工程坐标

    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.0.0.RELEASE</version>
    </parent>

2.2.2.添加web启动器

为了让SpringBoot帮我们完成各种自动配置，我们必须引入SpringBoot提供的自动配置依赖，我们称为启动器 starter 一个启动器包含了这个技术下所有的依赖。

常见启动器：

Spring Boot 应用启动器
spring Boot 应用启动器基本的一共有 44 种，具体如下：
1）spring-boot-starter
这是 Spring Boot 的核心启动器，包含了自动配置、日志和 YAML。
2）spring-boot-starter-actuator
帮助监控和管理应用。
3）spring-boot-starter-amqp
通过 spring-rabbit 来支持 AMQP 协议（Advanced Message Queuing Protocol）。
4）spring-boot-starter-aop
支持面向方面的编程即 AOP，包括 spring-aop 和 AspectJ。
5）spring-boot-starter-artemis
通过 Apache Artemis 支持 JMS 的 API（Java Message Service API）。
6）spring-boot-starter-batch
支持 Spring Batch，包括 HSQLDB 数据库。
7）spring-boot-starter-cache
支持 Spring 的 Cache 抽象。
8）spring-boot-starter-cloud-connectors
支持 Spring Cloud Connectors，简化了在像 Cloud Foundry 或 Heroku 这样的云平台上连接服务。
9）spring-boot-starter-data-elasticsearch
支持 ElasticSearch 搜索和分析引擎，包括 spring-data-elasticsearch。
10）spring-boot-starter-data-gemfire
支持 GemFire 分布式数据存储，包括 spring-data-gemfire。
11）spring-boot-starter-data-jpa
支持 JPA（Java Persistence API），包括 spring-data-jpa、spring-orm、hibernate。
12）spring-boot-starter-data-MongoDB
支持 MongoDB 数据，包括 spring-data-mongodb。
13）spring-boot-starter-data-rest
通过 spring-data-rest-webmvc，支持通过 REST 暴露 Spring Data 数据仓库。
14）spring-boot-starter-data-solr
支持 Apache Solr 搜索平台，包括 spring-data-solr。
15）spring-boot-starter-freemarker
支持 FreeMarker 模板引擎。
16）spring-boot-starter-groovy-templates
支持 Groovy 模板引擎。
17）spring-boot-starter-hateoas
通过 spring-hateoas 支持基于 HATEOAS 的 RESTful Web 服务。
18）spring-boot-starter-hornetq
通过 HornetQ 支持 JMS。
19）spring-boot-starter-integration
支持通用的 spring-integration 模块。
20）spring-boot-starter-jdbc
支持 JDBC 数据库。
21）spring-boot-starter-jersey
支持 Jersey RESTful Web 服务框架。
22）spring-boot-starter-jta-atomikos
通过 Atomikos 支持 JTA 分布式事务处理。
23）spring-boot-starter-jta-bitronix
通过 Bitronix 支持 JTA 分布式事务处理。
24）spring-boot-starter-mail
支持 javax.mail 模块。
25）spring-boot-starter-mobile
支持 spring-mobile。
26）spring-boot-starter-mustache
支持 Mustache 模板引擎。
27）spring-boot-starter-Redis
支持 Redis 键值存储数据库，包括 spring-redis。
28）spring-boot-starter-security
支持 spring-security。
29）spring-boot-starter-social-facebook
支持 spring-social-facebook
30）spring-boot-starter-social-linkedin
支持 pring-social-linkedin
31）spring-boot-starter-social-twitter
支持 pring-social-twitter
32）spring-boot-starter-test
支持常规的测试依赖，包括 JUnit、Hamcrest、Mockito 以及 spring-test 模块。
33）spring-boot-starter-thymeleaf
支持 Thymeleaf 模板引擎，包括与 Spring 的集成。
34）spring-boot-starter-velocity
支持 Velocity 模板引擎。
35）spring-boot-starter-web
S 支持全栈式 Web 开发，包括 Tomcat 和 spring-webmvc。
36）spring-boot-starter-websocket
支持 WebSocket 开发。
37）spring-boot-starter-ws
支持 Spring Web Services。
Spring Boot 应用启动器面向生产环境的还有 2 种，具体如下：
1）spring-boot-starter-actuator
增加了面向产品上线相关的功能，比如测量和监控。
2）spring-boot-starter-remote-shell
增加了远程 ssh shell 的支持。
最后，Spring Boot 应用启动器还有一些替换技术的启动器，具体如下：
1）spring-boot-starter-jetty
引入了 Jetty HTTP 引擎（用于替换 Tomcat）。
2）spring-boot-starter-log4j
支持 Log4J 日志框架。
3）spring-boot-starter-logging
引入了 Spring Boot 默认的日志框架 Logback。
4）spring-boot-starter-tomcat
引入了 Spring Boot 默认的 HTTP 引擎 Tomcat。
5）spring-boot-starter-undertow
引入了 Undertow HTTP 引擎（用于替换 Tomcat）。

因为我们是web项目，这里我们引入web启动器：

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

需要注意的是，我们并没有在这里指定版本信息。因为SpringBoot的父工程已经对版本进行了管理了。

这个时候，我们会发现项目中多出了大量的依赖：

这些都是SpringBoot根据spring-boot-starter-web这个依赖自动引入的，而且所有的版本都已经管理好，不会出现冲突。

2.2.3.管理jdk版本

默认情况下，maven工程的jdk版本是1.5，而我们开发使用的是1.8，因此这里我们需要修改jdk版本，只需要简单的添加以下属性即可：


    <properties>
        <java.version>1.8</java.version>
    </properties>

2.2.4.完整pom

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>com.mr</groupId>
    <artifactId>springboot-demo</artifactId>
    <version>1.0-SNAPSHOT</version>

    <properties>
        <java.version>1.8</java.version>
    </properties>

    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.0.0.RELEASE</version>
    </parent>

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

2.3.启动类

Spring Boot项目通过main函数即可启动，我们需要创建一个启动类：

然后编写main函数：

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

2.4.编写controller

接下来，我们就可以像以前那样开发SpringMVC的项目了

mvc也是属于springboot的一个模块

我们编写一个controller：

代码：

@RestController
public class HelloController {

    @GetMapping("hello")
    public String hello(){
        return "hello, spring boot!";
    }
}

2.5.启动测试

接下来，我们运行main函数，查看控制台：

打开页面访问：http://localhost:8080/hello

3.SpringBoot实践

3.1.整合SpringMVC

虽然默认配置已经可以使用SpringMVC了，不过我们有时候需要进行自定义配置。

3.1.1.修改端口

查看SpringBoot的全局属性可知，端口通过以下方式配置：

# 映射端口
server.port=80

3.1.2.访问静态资源

现在，我们的项目是一个jar工程，那么就没有webapp，我们的静态资源该放哪里呢？

回顾我们上面看的源码，有一个叫做ResourceProperties的类，里面就定义了静态资源的默认查找路径：

默认的静态资源路径为：

classpath:/META-INF/resources/
classpath:/resources/
classpath:/static/
classpath:/public

只要静态资源放在这些目录中任何一个，SpringMVC都会帮我们处理。

我们习惯会把静态资源放在classpath:/static/目录下。我们创建目录，并且添加一些静态资源：

然后就可以直接访问图片了

3.1.3.添加拦截器

首先我们定义一个拦截器：

package com.mr.interceptor;

import org.springframework.web.servlet.HandlerInterceptor;
import org.springframework.web.servlet.ModelAndView;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

//自定义拦截器，实现HandlerInterceptor

public class LoginIntegerceptor  implements HandlerInterceptor {

    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        System.out.println("pre is  running  now");
        return true;
    }

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

        System.out.println("postHandle is  running  now");
    }

    @Override
    public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception {
        System.out.println("afterCompletion is  running  now");
    }
}

然后，我们定义配置类，注册拦截器：

package com.mr.config;

import com.mr.interceptor.LoginIntegerceptor;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.context.annotation.Configuration;
import org.springframework.web.servlet.config.annotation.InterceptorRegistry;
import org.springframework.web.servlet.config.annotation.WebMvcConfigurer;

@Configuration//配置文件，启动项目默认加载此类
public class MvcConfig implements WebMvcConfigurer {

    //1:创建自定义拦截器类
    public LoginIntegerceptor getInter(){
        System.out.println("创建自定义拦截器");
        return new LoginIntegerceptor();
    }
    //2：将自定义拦截器，加入到mvc拦截器中，
    @Override
    public void addInterceptors(InterceptorRegistry registry) {

        System.out.println("增加拦截器");
        registry.addInterceptor(this.getInter()).addPathPatterns("/**");
    }
}

结构如下：

接下来运行并查看日志：

你会发现日志中什么都没有，因为我们记录的log级别是debug，默认是显示info以上，我们需要进行配置。

SpringBoot通过logging.level.*=debug来配置日志级别，*填写包名

# 设置com.mr包的日志级别为debug
logging.level.com.mr=debug

再次运行查看：

2018-05-05 17:50:01.811 DEBUG 4548 --- [p-nio-80-exec-1] com.mr.interceptor.LoginInterceptor   : preHandle method is now running!
2018-05-05 17:50:01.854 DEBUG 4548 --- [p-nio-80-exec-1] com.mr.interceptor.LoginInterceptor   : postHandle method is now running!
2018-05-05 17:50:01.854 DEBUG 4548 --- [p-nio-80-exec-1] com.mr.interceptor.LoginInterceptor   : afterCompletion method is now running!

3.2.整合jdbc

新建表

CREATE TABLE `t_user` (
  `user_id` int(11) NOT NULL AUTO_INCREMENT,
  `user_name` varchar(255) DEFAULT NULL,
  `user_pass` varchar(255) DEFAULT NULL,
  PRIMARY KEY (`user_id`)
) ENGINE=InnoDB AUTO_INCREMENT=54 DEFAULT CHARSET=utf8;

pom引入依赖

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-jdbc</artifactId>
</dependency>
<dependency>
    <groupId>mysql</groupId>
    <artifactId>mysql-connector-java</artifactId>
</dependency>

yml配置

spring:
  datasource:
    driver-class-name: com.mysql.jdbc.Driver
    url: jdbc:mysql://localhost:3306/mr
    username: root
    password: 123

新建contro

@Autowired
private DataSource dataSource;

@GetMapping("toUser")//只能接受get请求
public String toUser(){

    System.out.println("进入方法");

    try {
    //通过数据源获得链接，可以执行sql
       Connection connection= dataSource.getConnection();
        Statement statement=connection.createStatement();
        statement .execute("INSERT INTO t_user(user_name)  VALUES('tomcat')");

        System.out.println(connection);
    } catch (SQLException e) {
        e.printStackTrace();
    }
    return  "hello";
}

可以获得到链接就是正确

3.3.整合mybatis

pom导入启动器

SpringBoot官方并没有提供Mybatis的启动器，不过Mybatis官网自己实现了：

<!--mybatis -->
<dependency>
    <groupId>org.mybatis.spring.boot</groupId>
    <artifactId>mybatis-spring-boot-starter</artifactId>
    <version>1.3.2</version>
</dependency>

实体类

@Data
public class User {

    private Long userId;
    private String userName;
    private String userPass;
}

mapper:

我们需要给每一个Mapper接口添加@Mapper注解，才能被识别。

或者，我们也可以不加注解，而是在启动类上添加扫描包注解：

@Mapper
public interface UserMapper {
    //可以写新增方法，使用注解，不使用xml
      @Insert("INSERT INTO t_user(user_name)  VALUES(#{userName})")
     public void insertUser(User user);
}

@SpringBootApplication
@MapperScan("com.mr.mapper")
public class Application {
    public static void main(String[] args) {
        // 启动代码
        SpringApplication.run(Application.class, args);
    }
}

controller

@GetMapping("addUser")
  private void addUser(){

      System.out.println("进入增加方法"+userMapper);
      User user=new User();
      user.setUserName("清风明月");
      userMapper.insertUser(user);

  }

整合事务

至于事务，SpringBoot中通过注解来控制。就是我们熟知的@Transactional

@Service
public class UserService {

    @Autowired
    private UserMapper userMapper;

    public User queryById(Long id){
        return this.userMapper.selectByPrimaryKey(id);
    }

    @Transactional
    public void deleteById(Long id){
        this.userMapper.deleteByPrimaryKey(id);
    }
}

3.4整合连接池

连接池的作用：一个普通的Java程序，要查询数据库的数据每次访问数据库都要进行一次tcp连接和数据库认证等操作，而这些操作非常影响服务器的性能，连接池中放着数据库连接，应用服务需要的时候就去池子里面拿，用完之后归还给池子。数据库连接池负责分配、管理、释放数据库连接，它允许应用服务重复使用数据库连接，而非重新建立，数据库的连接创建和关闭均由连接池来实现。这样做的优点：减少网络开销，提升数据库性能

其实常见的连接池：c3p0，dbcp，德鲁伊，等

指定数据源连接属性参数：

引入Druid连接池依赖，也可以使用Druid官方提供的启动器：

整合连接池后，就不需要单独的jdbc配置了，使用连接池链接的配置就可以

<!-- Druid连接池 -->
<dependency>
    <groupId>com.alibaba</groupId>
    <artifactId>druid-spring-boot-starter</artifactId>
    <version>1.1.9</version>
</dependency>

yml

spring:
  datasource:
    driver-class-name: com.mysql.jdbc.Driver
    url: jdbc:mysql://127.0.0.1:3306/test
    username: root
    password:  root
    type: com.alibaba.druid.pool.DruidDataSource
    druid:
      # 初始化大小，最小，最大
      initial-size: 1
      min-idle: 1
      max-active: 20
      test-on-borrow: true
      stat-view-servlet:
        #是否允许开启监控
        enabled: true
        #登录用户名
        login-username: admin
        #登录密码
        login-password: 123456
        #是否允许重置监控数据
        reset-enable: false
        #druid访问路径
        url-pattern: /druid/*

druid监控界面http://127.0.0.1:8081/druid/index.html

清风明月_vip

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
springboot搭建解析

1.1.什么是SpringBootSpringBoot是Spring项目中的一个子工程，与我们所熟知的Spring-framework 同属于spring的产品:用一些固定的方式来构建生产级别的spring应用。Spring Boot 推崇约定大于配置的方式以便于你能够尽可能快速的启动并运行程序。1.2.为什么要学习SpringBootjava的开发框架设计模式还是比较麻烦的，各种配置，xml，等复杂的配置，项目各种配置繁琐，导致开发效率不高，xml较多，每个技术都要
复制链接

扫一扫