SpringBoot基础及使用

• 概述
• • 介绍
  • `HelloWorld`
  • • 创建工程
    • 添加`dao`层方法
    • 添加`service`层方法
    • 添加`SpringBoot`依赖
    • 添加`controller`层方法
    • 添加启动类
    • 项目部署
    • 服务器访问
• 核心配置
• • 配置文件
  • • 文件格式
    • 默认配置文件
  • 服务器参数
  • • 默认参数
    • 自定义参数
  • 静态资源
  • 拦截器
  • • 定义拦截器
    • 定义配置类
  • 字符编码
• `MyBatis`整合
• • 环境搭建
  • • 添加依赖
    • 环境配置
  • `dao`层逻辑
  • • 编写`entity`
    • 编写`dao`
    • `SQL`映射
  • `service`层逻辑
  • • 编写`service`
    • 属性注入
  • `controller`层逻辑
  • • 编写`controller`
    • 属性注入
  • 自动注入的方式
  • • 常见错误
    • 属性注入
    • 构造器注入
    • `setter`注入

  SpringBoot是基于Spring的JavaWeb工程框架，可以理解是SpringMVC的升级。SpringMVC开发项目时通常具有十分繁琐的配置，SpringBoot为大部分常用的配置提供了默认值，并为开发者提供了统一的修改入口。

  以下将以简单的工程(HelloWorld)介绍SpringBoot项目的基础搭建。

1.创建Maven工程
    (1).依次点击File -> New -> Project -> Maven,不选择模板(不勾选Create from archetype)
    (2).设置项目名称(HelloWorld)、工作空间等
    (3).设置项目坐标和版本
2.修改pom.xml(修改JDK版本，去除不必要的部分，添加插件等)
3.添加必要文件夹(src/main和src/test中的java文件夹和resources文件夹)
4.创建com.xxx.dao包
5.创建com.xxx.entity包
6.创建com.xxx.service包
7.创建com.xxx.controller包

  工程结构：

HelloWorld
    |---src
        |---main
            |---java
                |---com.xxx
                    |---controller
                    |---service
                    |---dao
                    |---entity
                    |---App.java
            |---resources
        |---test
    |---pom.xml

  在com.xxx.dao中添加类和方法：

package com.oner.dao;
public class DaoTest {
    public static String test() {
        return "DAO TEST.";
    }
}

  在com.xxx.service中添加类和方法：

package com.oner.service;
public class ServiceTest {
    public static String test() {
        
        return DaoTest.test() + "nr" + "SERVICE TEST.";
    }
}

  在pom.xml中添加SpringBoot父声明：

pom.xml

    ...
    
    
        org.springframework.boot
        spring-boot-starter-parent
        2.2.2.RELEASE
    
    
    com.oner
    HelloWorld
    1.0-SNAPSHOT
    
    
        
        
            org.springframework.boot
            spring-boot-starter-web
        
    
    
    
    

  在controller模块中新建包并添加类和方法：

package com.oner.controller;

@RestController
public class TestController {
    
    @GetMapping(value = "test")
    public String test() {
        
        return ServiceTest.test();
    }
}

  SpringBoot项目中需要使用一个启动类启动整个项目：

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

  SpringBoot自带Tomcat服务器，运行启动类中的main方法即可启动服务器。

  SpringBoot支持生成可执行的jar文件直接运行服务器。在pom.xml中添加插件：

    ...
    
    
        org.springframework.boot
        spring-boot-starter-parent
        2.2.2.RELEASE
    
    
    com.oner
    HelloWorld
    
    jar
    1.0-SNAPSHOT
    
    
        
        
            org.springframework.boot
            spring-boot-starter-web
        
    
    
    
        
            
            
                org.springframework.boot
                spring-boot-maven-plugin
            
        
    

  使用Maven命令运行controller模块：

clean compile package

  找到生成的目标jar包并使用Java命令执行，项目部署完毕。

java -jar controller.jar

  SpringBoot的默认服务器端口号为"8080",默认访问路径为"/".

  SpringBoot支持properties和yml两种格式的文件，例properties:

# 服务器端口号
server.port=8080
# 请求路径
server.servlet.context-path=/oner

  yml是一种通过行首间隔确定层级关系的配置文件：

server:
    # 同层级之间必须行首对齐
    port: 8080
    servlet:
        # 行首缩进更多的层级为上一行的子层级
        context-path: /oner

  SpringBoot的默认配置文件名为application.properties或application.yml。SpringBoot配置文件的默认位置在src/main/resources目录下。所有项目参数及设置都是通过此配置文件配置的。

HelloWorld
    |---src
        |---main
            |---java
            |---resources
                |---application.yml(application.properties)
                |---static
                |---public
                    |---index.xml
        |---test
    |---pom.xml

  SpringBoot的思想是约定大于配置，遵守这种思想可以快速搭建出稳定可靠的项目。SpringBoot同样支持自定义配置文件名及配置文件位置，但不建议这样做，这样的操作毫无意义，且破坏了约定大于配置的思想。

  SpringBoot自带Tomcat服务器，默认参数为：

端口号:8080
访问路径:/(即访问路径为空，直接在"http://ip:port/"之后追加请求路径即可)

  properties方式：

# 服务器端口号
server.port=8080
# 请求路径
server.servlet.context-path=/oner

  yml方式：

server:
  # 同层级之间必须行首对齐
  port: 8080
  servlet:
    # 行首缩进更多的层级为上一行的子层级
    context-path: /oner

  SpringBoot为静态资源提供了默认路径：

HelloWorld
    |---src
        |---main
            |---java
            |---resources
                |---static
                |---public
                    |---index.xml
        |---test
    |---pom.xml

  常用的静态资源路径有static和public.放在这些路径中的静态资源可以直接引用资源的相对路径(相对于static,public...)路径，例如static/js/script.js可以直接引用为js/script.js.
  传统的JavaWeb工程需要将静态资源置于webapp中，SpringBoot则将静态资源置于静态资源默认路径(常用例如static,public...)中，将index.html置于static中，访问站点名则自动跳转至index.html.

  SpringMVC定义拦截器后需要使用配置文件注册拦截器，而SpringBoot使用配置类注册拦截器。

public class UserInterceptor implements HandlerInterceptor {
    @Override
    public boolean preHandle(HttpServletRequest request,
                             HttpServletResponse response,
                             Object handler) throws Exception {
        if(request.getSession().getAttribute("user") == null) {
            
            response.sendRedirect(request.getContextPath() + "/login");
            
            return false;
        }
        return true;
    }
    @Override
    public void postHandle(HttpServletRequest request,
                           HttpServletResponse response,
                           Object handler,
                           @Nullable ModelAndView modelAndView) throws Exception {
        System.out.println("postHandle() is executed.");
    }
    @Override
    public void afterCompletion(HttpServletRequest request,
                                HttpServletResponse response,
                                Object handler,
                                @Nullable Exception exception) throws Exception {
        System.out.println("afterCompletion() is executed.");
    }
}

  WebMvcConfigurer接口用于配置SpringMVC相关的参数和设置。

@Configuration
public class InterceptorConfig implements WebMvcConfigurer {
    
    @Override
    public void addInterceptors(InterceptorRegistry registry) {
        String includes = {"/users","/balance"};
        String excludes = {"/users/icon"};
        
        
        registry.addInterceptor(new UserInterceptor())
            .addPathPatterns(includes).excludePathPatterns(excludes);
    }
}

  SpringBoot默认请求和响应的编码方式为UTF-8，也支持使用配置文件修改。使用properties:

application.properties

# 强制使用配置的编码
spring.http.encoding.force=true
spring.http.encoding.charset=UTF-8
spring.http.encoding.enabled=true

  使用yml:

application.yml

spring:
  http:
    encoding:
      # 强制使用配置的编码
      force: true
      charset: UTF-8
      enabled: true

    org.mybatis.spring.boot
    mybatis-spring-boot-starter
    2.1.3




    mysql
    mysql-connector-java




    com.alibaba
    druid
    1.2.4

  在SpringBoot配置文件中添加以下内容：

application.yml

spring:
  datasource:
    # 数据库连接池
    type: com.alibaba.druid.pool.DruidDataSource
    # 用户名
    username: root
    # 密码
    password: 123456
    # 数据库连接URL
    url: jdbc:mysql://localhost:3306/(略)...
    # 数据库驱动
    driver-class-name: com.mysql.cj.jdbc.Driver
        
mybatis:
  # type-aliases-package用于简化SQL映射文件中对实体类路径的引用
  # type-aliases-package指定实体类的包名后，SQL映射文件可直接引用实体类名作为实体类路径
  type-aliases-package: com.xxx.entity
  # SQL映射文件路径(置于resources目录下创建mappers目录)
  mapper-locations: mappers/*.xml
  configuration:
    # 开启数据库中下划线的驼峰规则转换
    map-underscore-to-camel-case: true

  SpringBoot整合MyBatis后，MyBatis的全局配置交由SpringBoot的配置文件完成，无需额外添加MyBatis全局配置文件。

public class User {
    private Integer id;
    private String name;
    private String password;
    
    public User() {super();}
    public User(Integer id,String name,String password) {
        this.id = id;
        this.name = name;
        this.password = password;
    }
    
    public Integer getId() {return id;}
    public void setId(Integer id) {this.id = id;}
    public String getName() {return name;}
    public void setName(String name) {this.name = name;}
    public String getPassword() {return password;}
    public void setPassword(String password) {this.password = password;}
    
    @Override
    public String toString() {
        return "id:" + id + "," 
            + "name:" + name + "," 
            + "password:" + password + ".";
    }
}

@Repository

@Mapper
public interface UserDao {
    void addUser(@Param("user") User user);
    User getUserByName(@Param("name") String name);
}

  @Mapper注解是MyBatis框架中的空注解(没有属性)，其作用是标记接口为SQL映射接口。通过在启动类上使用@MapperScan注解可起到相同的作用：

@SpringBootApplication

@MapperScan("com.xxx.dao")
public class App {
    public static void main(String[] args) {
        
        SpringApplication.run(App.class);
    }
}

    
    
        
        insert into users(name,password) values (#{user.name},#{user.password})
    
    
    
        select * from users where name = #{name}
    

@Service
public class UserService {
    private UserDao userDao;
    public void addUser(User user) {
        userDao.addUser(user);
    }
    public User getUserByName(String name) {
        return userDao.getUserByName(name);
    }
}

  MyBatis与SpringBoot整合后，SQL映射接口的代理对象会被SpringBoot处理为Bean置于Spring容器中，无需通过SqlSession获取，因此在service层可采用自动装配的属性注入获取dao层实例。

@Service
public class UserService {
    
    
    @Autowired
    private UserDao userDao;
    
    public void addUser(User user) {
        
        userDao.addUser(user);
    }
    public User getUserByName(String name) {
        
        return userDao.getUserByName(name);
    }
}

  @Autowired注解根据属性的类型进行自动装配，因此无法应付类型为继承同一个类或实现同一个接口的多个属性的自动装配，可以配合@Qualifier注解使用：

@Service
public class UserService {
    
    
    @Autowired
    
    @Qualifier(value = "userDao")
    private UserDao userDao;
    
    public void addUser(User user) {
        
        userDao.addUser(user);
    }
    public User getUserByName(String name) {
        
        return userDao.getUserByName(name);
    }
}

  @Resource注解是@Autowired和@Qualifier的结合：

@Service
public class UserService {
    
    
    
    @Resource(name = "userDao",type = com.xxx.dao.UserDao.class)
    private UserDao userDao;
    
    public void addUser(User user) {
        
        userDao.addUser(user);
    }
    public User getUserByName(String name) {
        
        return userDao.getUserByName(name);
    }
}

@Controller
public class UserController {
    
    private UserService userService;
    
    @ResponseBody
    public String test() {
        userService.addUser(new User(1,"Tony","123456"));
        return userService.getUserByName("Tony").toString();
    }
}

@Controller
public class UserController {
    
    
    @Autowired
    private UserService userService;
    
    @ResponseBody
    public String test() {
        
        userService.addUser(new User(1,"Tony","123456"));
        
        return userService.getUserByName("Tony").toString();
    }
}

  Spring容器的执行顺序是：先调用构造器创建Bean实例，再执行属性注入，因此在Bean的构造器中调用注入的属性会出现错误，因为此时Spring容器还没有执行属性注入。

@Service
public class UserService {
    
    
    @Autowired
    private UserDao userDao;
    
    public UserService() {
        
        userDao.addUser(new User(1,"Tony","123456"));
    }
    
    public void addUser(User user) {
        
        userDao.addUser(user);
    }
    public User getUserByName(String name) {
        
        return userDao.getUserByName(name);
    }
}

  @Autowired或其它注解修饰Bean的属性的方式称为属性注入，属性注入在Bean实例创建完成之后执行。

@Service
public class UserService {
    
    
    @Autowired
    private UserDao userDao;
    
    public void addUser(User user) {
        
        userDao.addUser(user);
    }
    public User getUserByName(String name) {
        
        return userDao.getUserByName(name);
    }
}

  @Autowired或其它注解修饰Bean的构造器的方式称为构造器注入，Spring容器将读取构造器的参数列表，然后对构造器参数进行自动装配。由于属性注入在构造器调用之后执行，构造器注入可以解决构造器调用注入的属性出错的问题。

@Service
public class UserService {
    
    private UserDao userDao;
    
    @Autowired
    public UserService(UserDao userDao) {
        this.userDao = userDao;
        userDao.addUser(new User(1,"Tony","123456"));
    }
    
    public void addUser(User user) {
        
        userDao.addUser(user);
    }
    public User getUserByName(String name) {
        
        return userDao.getUserByName(name);
    }
}

  @Autowired或其它注解修饰Bean的方法的方式称为setter注入，Spring容器会调用方法并读取方法的参数列表，然后对方法的参数进行自动装配。setter注入在Bean实例创建完成之后执行。

@Service
public class UserService {
    
    private UserDao userDao;
    
    
    @Resource(name = "userDao",type = com.xxx.dao.UserDao.class)
    public void setUserDao(UserDao userDao) {
        this.userDao = userDao;
    }
    
    public void addUser(User user) {
        
        userDao.addUser(user);
    }
    public User getUserByName(String name) {
        
        return userDao.getUserByName(name);
    }
}