java - springboot基础

qq_53601740

1969人浏览 · 2025-10-29 19:41:32

qq_53601740 · 2025-10-29 19:41:32 发布

一、springboot介绍

作用：其最主要作用就是帮助开发人员快速的构建庞大的spring项目，并且尽可能的减少一切xml配置，做到开箱即用。

特点：自动配置、起步依赖

二、创建springboot项目

1.创建maven项目

2.添加依赖

<?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>

    <!--添加父工程坐标-->
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.3.6.RELEASE</version>
    </parent>
    
    <groupId>com.demo</groupId>
    <artifactId>springboot_01</artifactId>
    <version>1.0-SNAPSHOT</version>

    <!--JDK版本-->
    <properties>
        <java.version>1.8</java.version>
    </properties>

    <!--添加web启动器 web项目需要-->
    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
    </dependencies>

    <!--引入spring‐boot‐starter；所有starter的基本配置-->
    <!--<dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter</artifactId>
    </dependency>-->

</project>

3.创建启动类（启动器创建在文件基层目录下，因为启动器启动时只会扫描当前所在包内的所有文件）

package com.demo;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
// @SpringBootConfiguration : 代表这个类就是一个配置类 , 本质上就是一个@Configuration注解
// @ComponentScan : 组件扫描, 默认扫描启动类所在包及子包下的类身上的注解
// @EnableAutoConfiguration : 自动配置注解 , 添加了此注解会自动去读取spring.factories配置文件中的自动配置类
public class Application {
    public static void main(String[] args) {
        SpringApplication.run(Application.class,args);
    }
}

4.配置文件：application.properties｜application.yaml，存放在resources文件夹下。

三、多环境配置文件切换

例：当前有application-dev.yml、application-pro.yml等配置文件（名称必须是application-***.yml）

将当前环境需要执行的配置文件在yml中进行指定即可。

# 激活配置文件
spring:
  profiles:
    active: dev

四、springboot自动配置

例：

yaml配置文件：

spring:
  jdbc:
    datasource:
      driverClassName: com.mysql.jdbc.driver
      url: jdbc:mysql:///springboot_01
      username: root
      password: root

自动配置bean（方式一）：

// Spring 容器管理，自动注册、扫描、依赖注入
@Component
public class DataSourceProperties {
    // 使用@Value获取配置文件信息
    @Value("${spring.jdbc.datasource.driverClassName}")
    private String driverClassName;
    @Value("${spring.jdbc.datasource.url}")
    private String url;
    @Value("${spring.jdbc.datasource.username}")
    private String username;
    @Value("${spring.jdbc.datasource.password}")
    private String password;

    // get、set方法自行增加
}

自动配置bean（方式二）：

package com.demo.properties;

import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.stereotype.Component;

@Component
// 获取配置文件指定路径下的内容
// 使用时需添加@EnableConfigurationProperties(DataSourceProperties2.class)注解才可使用
@ConfigurationProperties(prefix = "spring.jdbc.datasource")
public class DataSourceProperties2 {
    // 名称必须与配置文件里一致
    private String driverClassName;
    private String url;
    private String username;
    private String password;
    
     // 省略getter和setter.....
}

五、自定义启动器

例：配置一个数据库连接池启动器，后续项目需要用到时直接引入启动器依赖即可

1.pom文件（此处使用c3p0，是一种数据库连接池，现在有HikariCP（默认）、Druid、C3P0三种，推荐使用Druid可以进行辅助监控）

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

<properties>
    <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
    <java.version>1.8</java.version>
</properties>

<dependencies>
    <!--引入spring‐boot‐starter；所有starter的基本配置-->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter</artifactId>
</dependency>

    <!--自动配置连接池-->
    <dependency>
        <groupId>com.alibaba</groupId>
        <artifactId>druid</artifactId>
        <version>1.1.12</version>
</dependency>

<dependency>
            <groupId>c3p0</groupId>
            <artifactId>c3p0</artifactId>
            <version>0.9.1.2</version>
</dependency>

    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-configuration-processor</artifactId>
        <optional>true</optional>
    </dependency>
</dependencies>

2.创建配置类

package com.demo.autoconfig;

import org.springframework.boot.context.properties.ConfigurationProperties;

@Component
@ConfigurationProperties(prefix = "spring.jdbc.datasource")
public class DataSourceProperties {
    private String driverClassName ;
    private String url;
    private String username;
    private String password;
    // 生成set get toString方法   
}

3.创建自动装配类

package com.demo.autoconfig;

import com.alibaba.druid.pool.DruidDataSource;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.context.properties.EnableConfigurationProperties;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import javax.sql.DataSource;

@SpringBootConfiguration
@EnableConfigurationProperties(DataSourceProperties.class)
public class DataSourceAutoConfiguration {

    @Autowired
    private DataSourceProperties dataSourceProperties ;

    @Bean
    public DataSource createDataSource(){
        DruidDataSource dataSource = new DruidDataSource();
        dataSource.setDriverClassName(dataSourceProperties.getDriverClassName());
        dataSource.setUrl(dataSourceProperties.getUrl());
        dataSource.setUsername(dataSourceProperties.getUsername());
        dataSource.setPassword(dataSourceProperties.getPassword());
        return dataSource;
    }
}

4.yaml添加自动配置的配置属性

# Auto Configure
org.springframework.boot.autoconfigure.EnableAutoConfiguration=com.demo.autoconfig.DataSourceAutoConfiguration

5.项目二中引入自定义配置器

<dependency>
    <groupId>com.demo</groupId>
    <artifactId>spring-boot-jdbc-starter</artifactId>
    <version>1.0-SNAPSHOT</version>
</dependency>

6.项目二中配置数据库属性

spring:
  jdbc:
    datasource:
      driverClassName: com.mysql.jdbc.Driver
      url: jdbc:mysql:///springboot_01
      username: root
      password: root

7.项目二中使用

package com.demo.controller;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.context.properties.EnableConfigurationProperties;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

import javax.sql.DataSource;

@RestController
public class HelloController { 
    @Autowired
    private DataSource dataSource ;

    @RequestMapping(path = "/hello")
    public String sayHello() {
        System.out.println(dataSource.getClass());//打印DruidDataSource数据源
        return "Hello Spring Boot ! " ;
    }
 }

六、springboot整合springmvc

1.创建maven项目

2.pom文件

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

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

3.创建启动类

4.创建bean、controller等业务层

注意：默认静态资源目录如下，如果需要重新定义路径，需要自行配置

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

七、springboot编写拦截器（不像spring需要增加一系列xml配置）

1、编写拦截器

package com.demo.interceptor;
import org.springframework.stereotype.Component;
import org.springframework.web.servlet.HandlerInterceptor;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

@Component
public class MyInterceptor implements HandlerInterceptor {
    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        System.out.println("MyInterceptor拦截器的preHandle方法执行....");
        return false;
    }

    @Override
    public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView) throws Exception {
        System.out.println("MyInterceptor拦截器的postHandle方法执行....");
    }

    @Override
    public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception {
        System.out.println("MyInterceptor拦截器的afterCompletion方法执行....");
    }
}

2.注册拦截器

package com.demo.config;
import com.demo.interceptor.MyInterceptor;
import org.springframework.beans.factory.annotation.Autowired;
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 {

    @Autowired
    private MyInterceptor myInterceptor ;

    /**
     * /**  拦截当前目录及子目录下的所有路径 /user/**   /user/findAll  /user/order/findAll
     * /*   拦截当前目录下的以及子路径   /user/*     /user/findAll
     * @param registry
     */
    @Override
    public void addInterceptors(InterceptorRegistry registry) {
        registry.addInterceptor(myInterceptor).addPathPatterns("/**");
    }
}

八、springboot整合springdata jpa

1.创建maven项目

2.pom文件

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

    <properties>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
        <java.version>1.8</java.version>
    </properties>

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

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

        <!-- springBoot JPA的起步依赖 -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-jpa</artifactId>
        </dependency>

        <!-- MySQL连接驱动 -->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
        </dependency>

    </dependencies>

3.yml配置文件

logging:
  level:
    com.demo.dao: debug # 配置日志
spring:
  datasource:
    username: root
    password: root
    url: jdbc:mysql://127.0.0.1:3306/springboot?useUnicode=true&characterEncoding=utf8&serverTimezone=Asia/Shanghai
    driver-class-name: com.mysql.cj.jdbc.Driver
  jpa:
    database: mysql
    show-sql: true
    generate-ddl: true
    hibernate:
      ddl-auto: update
      naming_strategy: org.hibernate.cfg.ImprovedNamingStrategy
server:
  port: 8081

4.创建实体bean

package com.demo.domain;
import javax.persistence.*;

// 必须 - 标识这是一个 JPA 实体
@Entity
// 可以省略 - 默认表名就是类名 User
@Table(name = "user")
public class User{
    // 必须 - 标识主键字段
    @Id
    // 建议保留 - 明确主键生成策略，自处是自增
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    // 可以省略 - 默认列名就是字段名 username
    @Column(name = "id")
    private Long id;
    @Column(name = "username")
    private String username;
    @Column(name = "password")
    private String password;
    @Column(name = "name")
    private String name;
 
    //此处省略setter和getter方法... ...
}

5.创建实现接口

package com.demo.dao;

import com.demo.domain.User;
import org.springframework.data.jpa.repository.JpaRepository;

// 实现JpaRepository
public interface UserDao extends JpaRepository<User,Integer> {
}

6.创建service接口

package com.demo.service;

import com.demo.domain.User;
import java.util.List;

public interface UserService {
    List<User> findUsers();

    User findUserById(Long id);

    void saveUser(User user);

    void updateUser(User user);

    void deleteUserById(Long id);
}

7.实现service

package com.demo.service.impl;

import com.demo.dao.UserDao;
import com.demo.domain.User;
import com.demo.service.UserService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import java.util.List;

@Service
public class UserServiceImpl implements UserService {

    @Autowired
    private UserDao userDao;

    /**
     * 查询所有
     * @return
     */
    @Override
    public List<User> findUsers() {
        return userDao.findAll();
    }
    /**
     * 根据id查询
     * @return
     */
    @Override
    public User findUserById(Long id) {
        return userDao.findById(id).get();
    }
    /**
     * 保存
     * @return
     */
    @Override
    public void saveUser(User user) {
        userDao.save(user);
    }
    /**
     * 更新（更新保存都是save，会根据id，有则更新，无则保存）
     * @return
     */
    @Override
    public void updateUser(User user) {
        userDao.save(user);
    }
    /**
     * 根据id删除
     * @return
     */
    @Override
    public void deleteUserById(Long id) {
        userDao.deleteById(id);
    }
}

九、springboot整合tkmybatis+web项目

1.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>

<parent>

<groupId>org.springframework.boot</groupId>

<artifactId>spring-boot-starter-parent</artifactId>

<version>2.3.6.RELEASE</version>

</parent>

<dependencies>

<dependency>

<groupId>org.springframework.boot</groupId>

<artifactId>spring-boot-starter-test</artifactId>

</dependency>

<dependency>

<groupId>tk.mybatis</groupId>

<artifactId>mapper-spring-boot-starter</artifactId>

<version>2.1.5</version>

</dependency>

<dependency>

<groupId>org.springframework.boot</groupId>

<artifactId>spring-boot-starter-jdbc</artifactId>

</dependency>

<dependency>

<groupId>mysql</groupId>

<artifactId>mysql-connector-java</artifactId>

<version>5.1.47</version>

</dependency>

<dependency>

<groupId>com.alibaba</groupId>

<artifactId>druid-spring-boot-starter</artifactId>

<version>1.1.10</version>

</dependency>

<dependency>

<groupId>org.springframework.boot</groupId>

<artifactId>spring-boot-starter-web</artifactId>

</dependency>

<dependency>

<groupId>org.springframework.boot</groupId>

<artifactId>spring-boot-starter-actuator</artifactId>

</dependency>

<dependency>

<groupId>org.apache.commons</groupId>

<artifactId>commons-lang3</artifactId>

</dependency>

<dependency>

<groupId>org.springframework.boot</groupId>

<artifactId>spring-boot-devtools</artifactId>

<scope>runtime</scope>

<optional>true</optional>

</dependency>

</dependencies>

<build>

<plugins>

<plugin>

<groupId>org.springframework.boot</groupId>

<artifactId>spring-boot-maven-plugin</artifactId>

</plugin>

</plugins>

</build>

</project>

2.创建启动类

package com.demo;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import tk.mybatis.spring.annotation.MapperScan;

@SpringBootApplication
// 自动扫描并注册 MyBatis Mapper 接口，无需为每个 Mapper 接口单独添加 @Mapper 注解。
@MapperScan(basePackages = "com.deom.dao")
// 启用 Spring 的注解驱动事务管理，让 @Transactional 注解生效。
@EnableTransactionManagement
public class Application {
    public static void main(String[] args) {
        SpringApplication.run(Application.class,args);
    }
}

3.yml配置文件

server:
  port: 10001
spring:
  datasource:
    driver-class-name: com.mysql.jdbc.Driver
    url: jdbc:mysql:///springboot
    username: root
    password: root
    type: com.alibaba.druid.pool.DruidDataSource
mybatis:
  type-aliases-package: com.demo.pojo

4.创建实体bean

package com.demo.pojo;

import java.io.Serializable;

@Entity
@Table(name = "tx_user")
public class User implements Serializable {
    @Id
    private Integer id;
    private String name;
    private String gender;
    private Integer age;
    private String address;
    private String qq;
    private String email;
    private String username;
    private String phone;
…

5.mapper接口映射

package com.demo.dao;

import com.demo.pojo.User;
import tk.mybatis.mapper.common.Mapper;
import java.util.List;

public interface UserMapper extends Mapper<User> {
}

6.创建接口

public interface UserService {

    /**
     * 查询所有用户信息
     * @return
     */
    public List<User> findAll();
}

7.创建实现类

package com.demo.service.impl;

import com.demo.dao.UserMapper;
import com.demo.pojo.User;
import com.demo.service.UserService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import java.util.List;

@Service
public class UserServiceImpl implements UserService {
    @Autowired
    private UserMapper userMapper;

    @Override
    // 事务
    @Transactional(readOnly = true ,propagation = Propagation.SUPPORTS)
        public List<User> findAll() {
            return userMapper.selectAll();
    }
}

十、tkmybatis、mybatis、mybatisplus、springdata jpa区别

tkmybatis - mybatis的升级版，简单crud，无需自己写sql，复杂sql通过@select写，无缝切入mybatis。

mybatis - 支持复杂化sql，需要自己写sql

mybatisplus - 支持更加复杂、多样化的sql诉求，基础crud也可以不用写

springdata jpa - 简单业务，无需自己写sql

十一、springboot项目打包部署

1.添加依赖

<build>
    <plugins>
        <!-- 打jar包时如果不配置该插件，打出来的jar包没有清单文件 -->
        <plugin>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-maven-plugin</artifactId>
        </plugin>
    </plugins>
</build>

2.跳过测试（避免测试环节出错）