SpringBoot

一、快速啟動

建立SpringBoot專案

由於本人是eclipse愛好者，這裡僅介紹使用eclipse的STS外掛快速建立SpringBoot專案的方法；

1. 百度一下，安裝好STS外掛；
2. 新建專案Spring Starter Project；
3. 填一些資訊，選一些依賴的模組，完成；
4. 等待maven下載依賴；

這裡貼一份不會報錯的pom.xml:

<?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 https://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.4.0</version>
		<relativePath/> <!-- lookup parent from repository -->
	</parent>
	<groupId>com.example</groupId>
	<artifactId>demo2</artifactId>
	<version>0.0.1-SNAPSHOT</version>
	<name>demo2</name>
	<description>Demo project for Spring Boot</description>

	<properties>
		<java.version>1.8</java.version>
		<maven-jar-plugin.version>3.1.1</maven-jar-plugin.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>
	</dependencies>

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

</project>

注意<maven-jar-plugin.version>3.1.1</maven-jar-plugin.version>最好寫上，不然可能會報錯；

我們寫一個Controller測試一下：

package com.example.demo.controller;

import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class HelloController {
	@RequestMapping("/test")
	public String test() {
		return "STS test";
	}
}

然後直接執行根目錄下的那個application.java檔案，它是整個springboot專案的啟動類；

就ok了；

為什麼沒有tomcat？

因為我們選了web模組依賴，已經內嵌了tomcat；

配置檔案

專案建立好之後會有一個預設的配置檔案:application.properties;

如果我們要改內嵌tomcat的http埠的話，寫入server.port=8888即可；

但是springboot還提供了另一種方式的配置檔案：yml檔案；

類似這樣：

server: 
  port: 8888

注意冒號後面必須跟空格；

二、SpringBoot整合Web

整合servlet

想要整合servlet也還是可以的，雖然感覺沒啥必要了；

還是像以前那樣寫一個Servlet，繼承HTTPServlet，重寫service方法：

package com.example.demo.servlet;

import java.io.IOException;

import javax.servlet.ServletException;
import javax.servlet.annotation.WebServlet;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

@WebServlet(name="TestServlet",urlPatterns = "/test")
public class TestServlet extends HttpServlet{
	private static final long serialVersionUID = 1L;

	@Override
	protected void service(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
		resp.getWriter().write("<h1>Servlet in SpringBoot</h1>");
	}
}

我們只要在啟動類那邊多加一個註解:@ServletComponentScan，讓它可以掃描servlet的註解就可以了

package com.example.demo;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.boot.web.servlet.ServletComponentScan;

@SpringBootApplication
@ServletComponentScan
public class SpringBootWebApplication {

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

}

整合filter

沒錯，我們只要想之前那樣寫一個filter就可以了，@ServletComponentScan註解不僅會掃描servlet註解，也會掃描filter的註解。

package com.example.demo.filter;

import java.io.IOException;

import javax.servlet.FilterChain;
import javax.servlet.ServletException;
import javax.servlet.annotation.WebFilter;
import javax.servlet.http.HttpFilter;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

@WebFilter(filterName = "TestFilter",urlPatterns = "/*")
public class TestFilter extends HttpFilter{
	private static final long serialVersionUID = 1L;

	@Override
	public void init() throws ServletException {
		// TODO Auto-generated method stub
		super.init();
	}
	
	@Override
	public void destroy() {
		// TODO Auto-generated method stub
		super.destroy();
	}
	
	@Override
	protected void doFilter(HttpServletRequest req, HttpServletResponse resp, FilterChain chain)
			throws IOException, ServletException {
		System.out.println("start");
		chain.doFilter(req, resp);
		System.out.println("end");
	}
}

訪問靜態資源

沒有webcontent了，要把靜態資源放哪裡呢？

放在resource資料夾裡面的static裡即可。

注意到還有一個資料夾叫做template，它是用來放動態頁面的；

但是jsp不行，因為springboot已經不推薦jsp作為動態頁面了，它們推薦的是Thymeleaf；

檔案上傳

先寫一個檔案上傳的頁面

<!DOCTYPE html>
<html>
<head>
<meta charset="UTF-8">
<title>upload file</title>
</head>
<body>
	<form action="fileUpload" method="post" enctype="multipart/form-data">
		<input type="file" name="file" /> <br> <br> <input
			type="submit" value="上傳" />
	</form>
</body>
</html>

寫一個controller接收上傳的檔案

package com.example.demo.controller;

import java.io.File;

import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import org.springframework.web.multipart.MultipartFile;

@RestController
public class FileUploadController {
	@RequestMapping("/fileUpload")
	public String fileUpload(MultipartFile file) {
		System.out.println(file.getOriginalFilename());
		try {
			String basePath = System.getProperty("user.dir") + "/src/main/resources/static/img/";
			file.transferTo(new File(basePath + file.getOriginalFilename()));
		} catch (Exception e) {
			e.printStackTrace();
			return "ERROR";
		}
		return "OK";
	}
}

同時我們在配置檔案裡面要配置一下允許的檔案大小和單次請求的大小,省得大檔案直接報錯：

server: 
  port: 8888

spring: 
  servlet:
    multipart:
      max-file-size: 1000MB
      max-request-size: 1000MB

三、SpringBoot整合JDBC

依賴

除了web啟動器之外，我們還需要在pom.xml裡面加入資料庫驅動和JDBC啟動器以及資料來源：

<!-- JDBC啟動器 -->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-jdbc</artifactId>
</dependency>

<!-- mysql連線 -->
<dependency>
    <groupId>mysql</groupId>
    <artifactId>mysql-connector-java</artifactId>
    <version>5.1.6</version>
</dependency>

<!-- Druid 資料來源 -->
<dependency>
    <groupId>com.alibaba</groupId>
    <artifactId>druid</artifactId>
    <version>1.1.12</version>
</dependency>

Druid並不是必需的，SpringBoot預設提供HikariCP作為資料來源；

配置

配置非常簡單，yml裡面按如下格式配一下就行了：

server: 
  port: 8888

spring: 
  datasource:
    url: jdbc:mysql://localhost:3306/test2?useUnicode=true&characterEncoding=UTF-8&useSSL=false
    driver-class-name: com.mysql.jdbc.Driver
    username: root
    password: *********
    type: com.alibaba.druid.pool.DruidDataSource

type指定了資料來源，預設的是HikariCP。

使用

結構和以前使用Jdbc是一模一樣的，pojo，dao，service，controller；

假設我們要查詢所有使用者；

pojo：

package com.example.demo.pojo;

public class User {
	private String name;
	private String sex;
	private int age;

	public String getName() {
		return name;
	}

	public void setName(String name) {
		this.name = name;
	}

	public String getSex() {
		return sex;
	}

	public void setSex(String sex) {
		this.sex = sex;
	}

	public int getAge() {
		return age;
	}

	public void setAge(int age) {
		this.age = age;
	}

	@Override
	public String toString() {
		return "User [name=" + name + ", sex=" + sex + ", age=" + age + "]";
	}

}

controller:

package com.example.demo.controller;

import java.util.List;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

import com.example.demo.pojo.User;
import com.example.demo.service.UserService;

@RestController
public class TestJdbc {
	@Autowired
	private UserService userService;

	@RequestMapping("/showUser")
	public List<User> showUser() {
		return userService.getAllUsers();
	}
}

service:

package com.example.demo.service.impl;

import java.util.List;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import com.example.demo.dao.UserDao;
import com.example.demo.pojo.User;
import com.example.demo.service.UserService;

@Service
public class UserServiceImpl implements UserService {
	@Autowired
	private UserDao userDao;

	@Override
	public List<User> getAllUsers() {
		return userDao.getAllUsers();
	}

}

dao:

package com.example.demo.dao.impl;

import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.List;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.jdbc.core.RowMapper;
import org.springframework.stereotype.Repository;

import com.example.demo.dao.UserDao;
import com.example.demo.pojo.User;

@Repository
public class UserDaoImpl implements UserDao {

	@Autowired
	private JdbcTemplate jdbcTemplate;

	@Override
	public List<User> getAllUsers() {
		String sql = "select * from User";
		return jdbcTemplate.query(sql, new RowMapper<User>() {
			@Override
			public User mapRow(ResultSet rs, int rowNum) throws SQLException {
				User u = new User();
				u.setAge(rs.getInt("age"));
				u.setName(rs.getString("name"));
				u.setSex(rs.getString("sex"));
				return u;
			}
		});
	}

}

跟以前唯一不一樣的大概就是dao層了，之前我們需要自己去載入JDBC驅動，現在不這麼幹了。

我們直接注入JdbcTemplate,通過它來做資料庫的操作。

這部分內容並不是很重要，因為我們以後肯定是要通過一些持久層框架，如Mybatis等來做資料庫的互動的，所以我就不寫那麼細了，也沒啥好寫的。

四、SpringBoot整合Mybatis（重點）

依賴

我們需要新增以下的啟動器：

Web、Mybatis、Jdbc、Mysql

當然如果我們要用Druid資料來源的話，別忘了：

<!-- Druid 資料來源 -->
<dependency>
    <groupId>com.alibaba</groupId>
    <artifactId>druid</artifactId>
    <version>1.1.12</version>
</dependency>

配置

1. 親測driverClassName不寫也可以；
2. 另外我們需要配置將xml檔案放在哪裡，這裡和以前不一樣，要把xml放在resource下，我這裡放在了resource下的mapper資料夾下；
3. url中必須新增時區；

server: 
  port: 8888
  
spring: 
  datasource:
    url: jdbc:mysql://localhost:3306/test2?useUnicode=true&characterEncoding=UTF-8&useSSL=false&serverTimezone=Asia/Shanghai
#    driver-class-name: com.mysql.jdbc.Driver
    username: root
    password: lijingjing
    type: com.alibaba.druid.pool.DruidDataSource

mybatis:
  mapper-locations: classpath:/mapper/*.xml

使用

首先我們要在啟動類上面加一個註解掃描mapper包：@MapperScan("com.ljj.SpringBootMybatis.mapper")，這樣才能將Mapper注入到ioc容器中；

package com.ljj.SpringBootMybatis;

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

@SpringBootApplication
@MapperScan("com.ljj.SpringBootMybatis.mapper")
public class SpringBootMybatisApplication {

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

}

之前的SSM中，我們往往是將介面和xml都放在mapper裡面，現在需要分開放；

將介面還是放在原來的位置，但是將xml檔案放在resource中，我這裡是放在resource中的mapper資料夾下；

介面：

package com.ljj.SpringBootMybatis.mapper;

import java.util.List;

import com.ljj.SpringBootMybatis.pojo.User;

public interface UserMapper {
	public List<User> getAllUsers();
}

xml：

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.ljj.SpringBootMybatis.mapper.UserMapper">
	<select id="getAllUsers" resultType="com.ljj.SpringBootMybatis.pojo.User">
		select * from user
	</select>
</mapper>

剩餘部分就還是老規矩，service、controller以前怎麼寫，現在還是怎麼寫，沒有變化；

五、其他

熱部署

只針對eclipse而言；

首先要確保project–>build automatically的勾勾是選上的；

在pom.xml裡面新增依賴：

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

沒錯，這樣就可以了。

日誌管理

這裡就不細說了，也不配置詳細的日誌管理的檔案了，就簡單試用一下；

配置檔案中配一下這個：

logging: 
  path: log

這樣的話，就會在專案根目錄建立一個log資料夾，裡面會有一個spring.log的檔案記錄日誌；

如果我們要遮蔽一些包的日誌輸出，可以：

logging: 
  path: log
  level: 
    org: off

這樣就遮蔽了org包下的日誌輸出；

在程式碼裡面就更簡單了：

package com.ljj.SpringBootLog.controller;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class HelloController {

	private static Logger logger = LoggerFactory.getLogger(HelloController.class);

	@RequestMapping("/test")
	public String test() {
		logger.info("日誌輸出");
		return "OK";
	}
}

專案打包與部署

很簡單，右鍵run as–>maven install;

完成後target目錄中會出現一個jar包，我們只要在控制檯java -jar jar名稱即可執行專案；

如果我們希望程式在linux上後臺執行，只要java -jar jar名稱 &即可；