SpringBoot概述-配置-整合SSM

SpringBoot概述-配置-整合SSM

• 1.概述：
• 2.快速入门
• 3.java配置应用
• 4.SpringBoot属性注入
• 5. 更优雅的注入
• 6. Yaml配置文件
• • 多个Yaml文件
• 7.SpringBoot实践(整合SSM)

1.概述：

Spring Boot是Spring项目中的一个子工程，与我们所熟知的Spring-framework 同属于spring的产品: 一般把Spring Boot称为搭建程序的 脚手架 或者说是便捷搭建 基于Spring的工程 脚手架。其最主要作用就是帮助开 发人员快速的构建庞大的spring项目，并且尽可能的减少一切xml配置，做到开箱即用，迅速上手，让开发人员关注 业务而非配置。

2.快速入门

• 创建maven 工程
• 添加依赖 添加父工程坐标

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

添加web启动器： 为了让Spring Boot帮我们完成各种自动配置，我们必须引入Spring Boot提供的自动配置依赖，我们称为 启动器 。因 为我们是web项目，这里我们引入web启动器，在 pom.xml 文件中加入如下依赖：

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

管理jdk版本 如果我们想要修改Spring Boot项目的jdk版本，只需要简单的添加以下属性即可，如果没有需求，则不添加。同样的 在 pom.xml 文件中添加如下：

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

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

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

• 编写controller 像以前那样开发SpringMVC的项目：

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

• 启动测试 运行main 函数，观察控制台 并且可以看到监听的端口信息：
• 监听的端口是8080
• SpringMVC的项目路径是：空
• /hello 路径已经映射到了 HelloController中的hello() 方法 打开页面访问：http://localhost:8080/hello

3.java配置应用

以前SpringMVC配置数据连接池：

<!– 配置连接池 –>
<bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource" init-method="init" destroy-method="close">
<property name="url" value="${jdbc.url}" />
<property name="username" value="${jdbc.username}" />
<property name="password" value="${jdbc.password}" />
</bean>

使用java进行配置：

• @Configuration：声明一个类作为配置类，代替xml文件
• @Bean：声明在方法上，将方法的返回值加入Bean容器，代替 标签
• @PropertySource：指定外部属性文件 步骤：

<dependency>
<groupId>com.alibaba</groupId>
<artifactId>druid</artifactId>
<version>1.1.6</version>
</dependency>

package com.xxx.config;
import com.alibaba.druid.pool.DruidDataSource;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.PropertySource;

import javax.sql.DataSource;
/*
@Configuration ：声明我们 JdbcConfig 是一个配置类
@PropertySource ：指定属性文件的路径是: classpath:jdbc.properties
通过 @Value 为属性注入值
通过@Bean将 dataSource() 方法声明为一个注册Bean的方法，Spring会自动调用该方法，将方法的返回值
加入Spring容器中。
*/
@Configuration
@PropertySource("classpath:jdbc.properties")
public class JdbcConfig {
@Value("${jdbc.url}")
String url;
@Value("${jdbc.driverClassName}")
String driverClassName;
@Value("${jdbc.username}")
String username;
@Value("${jdbc.password}")
String password;
@Bean
public DataSource dataSource(){
DruidDataSource dataSource = new DruidDataSource();
dataSource.setDriverClassName(driverClassName);
dataSource.setUrl(url);
dataSource.setUsername(username);
dataSource.setPassword(password);
return dataSource;
}
}

• 在 HelloController 中注入DataSource进行测试

@RestController
public class HelloController {
@Autowired
private DataSource dataSource;
@GetMapping("hello")
public String hello() {
System.out.println("dataSource = " + dataSource);
return "hello, spring boot!";
}
}

4.SpringBoot属性注入

在上面的案例中，我们实验了java配置方式。不过属性注入使用的是@Value注解。这种方式虽然可行，但是不够强 大，因为它只能注入基本类型值。 在Spring Boot中，提供了一种新的属性注入方式，支持各种java基本数据类型及复杂类型的注入。 1> 新建config\\JdbcProperties.java

package com.xxx.config;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.boot.context.properties.ConfigurationProperties;
@ConfigurationProperties(prefix = "jdbc")
public class JdbcProperties {
private String url;
private String driverClassName;
private String username;
private String password;
// …略 getters 和setters
}

• 在类上通过@ConfigurationProperties注解声明当前类为属性读取类
• prefix=“jdbc” 读取属性文件中，前缀为jdbc的值
• 在类上定义各个属性，名称必须与属性文件中 jdbc. 后面部分一致
• 需要注意的是，这里我们并没有指定属性文件的地址，所以我们需要把jdbc.properties名称改为application.properties，这是Spring Boot默认读取的属性文件名 2>将 JdbcConfig 类原来全部注释掉或删除，修改为如下内容

@Configuration
@EnableConfigurationProperties(JdbcProperties.class)
public class JdbcConfig {
@Bean
public DataSource dataSource(JdbcProperties jdbc) {
DruidDataSource dataSource = new DruidDataSource();
dataSource.setUrl(jdbc.getUrl());
dataSource.setDriverClassName(jdbc.getDriverClassName());
dataSource.setUsername(jdbc.getUsername());
dataSource.setPassword(jdbc.getPassword());
return dataSource;
}

5. 更优雅的注入

事实上，如果一段属性只有一个Bean需要使用，我们无需将其注入到一个类（JdbcProperties，将该类上的所有注 解去掉）中。而是直接在需要的地方声明即可；再次修改 JdbcConfig 类为如下代码：

@Configuration
public class JdbcConfig {
@Bean
// 声明要注入的属性前缀，Spring Boot会自动把相关属性通过set方法注入到DataSource中
@ConfigurationProperties(prefix = "jdbc")
public DataSource dataSource() {
return new DruidDataSource();
}
}

我们直接把 @ConfigurationProperties(prefix = “jdbc”) 声明在需要使用的 @Bean 的方法上，然后Spring Boot就会自动调用这个Bean（此处是DataSource）的set方法，然后完成注入。使用的前提是：该类必须有对应属 性的set方法！

6. Yaml配置文件

配置文件除了可以使用application.properties类型，还可以使用后缀名为：.yml或者.yaml的类型，也就是： application.yml或者application.yaml 基本格式：

jdbc:
driverClassName: com.mysql.jdbc.Driver
url: jdbc:mysql://127.0.0.1:3306/test
username: root
password: root

如果两个配置文件都有，会把两个文件的配置合并，如果有重复属性，以properties中的为准 如果是配置数组、list、set等结构的内容，那么在yml文件中格式为： key:

• value1
• value2

多个Yaml文件

当一个项目中有多个yml配置文件的时候，可以以application-**.yml命名；在application.yml中配置项目使用激活 这些配置文件即可。 创建 application-abc.yml 文件如下：

a:
url: http://www.xxx.cn

创建 application-def.yml 文件如下：

b:
url: http://www.xxx.com

在 application.yml 文件中添加如下配置：

#加载其它配置文件
spring:
profiles:
active: abc,def

多个文件名只需要写application-之后的名称，在多个文件之间使用,隔开。

7.SpringBoot实践(整合SSM)

public class User{
// id
private Long id;
// 用户名
private String userName;
// 密码
private String password;
// 姓名
private String name;
// 年龄
private Integer age;
// 性别，1男性，2女性
private Integer sex;
// 出生日期
private Date birthday;
// 创建时间
private Date created;
// 更新时间
private Date updated;
// 备注
private String note;
// getter和setter省略
}

<dependency>
<groupId>org.projectlombok</groupId>
<artifactId>lombok</artifactId>
</dependency>

然后可以在Bean上使用： @Data ：自动提供getter和setter、hashCode、equals、toString等方法 @Getter：自动提供getter方法 @Setter：自动提供setter方法 @Slf4j：自动在bean中提供log变量，其实用的是slf4j的日志功能。

logging:
level:
com.xxx: debug
org.springframework: info

# 映射端口
server:
port: 80

import lombok.extern.slf4j.Slf4j;
import org.springframework.web.servlet.HandlerInterceptor;
import org.springframework.web.servlet.ModelAndView;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
@Slf4j
public class MyInterceptor implements HandlerInterceptor {
@Override
public boolean preHandle(HttpServletRequest request, HttpServletResponse response,Object handler) throws Exception {
log.debug("这是MyInterceptor拦截器的preHandle方法");
return true;
}
@Override
public void postHandle(HttpServletRequest request, HttpServletResponse response,Object handler, ModelAndView modelAndView) throws Exception {
log.debug("这是MyInterceptor拦截器的postHandle方法");
}
@Override
public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception {
log.debug("这是MyInterceptor拦截器的afterCompletion方法");
}
}

步骤二：定义配置类\\config\\MvcConfig.java ，用于注册拦截器，内容如下：

import com.xxx.interceptor.MyInterceptor;
import org.springframework.context.annotation.Bean;
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 {
/**
* 将拦截器注册到spring ioc容器
* @return myInterceptor
*/
@Bean
public MyInterceptor myInterceptor(){
return new MyInterceptor();
}
/**
* 重写该方法；往拦截器链添加自定义拦截器
* @param registry 拦截器链
*/
@Override
public void addInterceptors(InterceptorRegistry registry) {
//通过registry添加myInterceptor拦截器，并设置拦截器路径为 /*
registry.addInterceptor(myInterceptor()).addPathPatterns("/*");
}
}

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

当然，不要忘了数据库驱动，SpringBoot并不知道我们用的什么数据库，这里我们选择MySQL；同样的在 pom.xml文件中添加如下依赖：

<dependency>
<groupId>mysql</groupId>
<artifactId>mysql-connector-java</artifactId>
<version>5.1.46</version>
</dependency>

至于事务，SpringBoot中通过注解来控制。就是我们熟知的 @Transactional 使用的时候设置在对应的类或方法上 即可。

import com.xxx.pojo.User;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
@Service
public class UserService {
public User queryById(Long id){
//根据id查询
return new User();
}
@Transactional
public void saveUser(User user){
System.out.println("新增用户…");
}
}

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

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

9.2>配置 application.yml ，常用配置如下：

# mybatis配置
mybatis:
# 实体类别名包路径
type-aliases-package: com.xxx.pojo
# 映射文件路径
# mapper-locations: classpath:mappers/*.xml
configuration:
# 控制台输出执行sql
log-impl: org.apache.ibatis.logging.stdout.StdOutImpl

9.3> 配置Mapper扫描 需要注意，这里没有配置mapper接口扫描包，因此我们需要给每一个Mapper接口添加 @Mapper 注解，才能被识 别。

@Mapper
public interface UserMapper {
}

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

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

9.4> 通用mapper 步骤一：通用Mapper的作者也为自己的插件编写了启动器，我们直接引入即可。在项目的 pom.xml 文件中加入如下依 赖

<dependency>
<groupId>tk.mybatis</groupId>
<artifactId>mapper-spring-boot-starter</artifactId>
<version>2.1.5</version>
</dependency>

注意：一旦引入了通用Mapper的启动器，会覆盖Mybatis官方启动器的功能，因此需要移除对官方Mybatis启动器 的依赖。 步骤二：编写UserMapper 创建\\mapper\\UserMapper.java

import com.xxx.pojo.User;
import tk.mybatis.mapper.common.Mapper;
public interface UserMapper extends Mapper<User> {
}

步骤三：把启动类上的@MapperScan注解修改为通用mapper中自带的： import tk.mybatis.spring.annotation.MapperScan; 步骤四:在User实体类上加JPA注解 /pojo/User.java

@Data
@Table(name = "tb_user")
public class User{
// id
@Id
//开启主键自动回填
@KeySql(useGeneratedKeys = true)
private Long id;
// 用户名
private String userName;
// 密码
private String password;
// 姓名
private String name;
// 年龄
private Integer age;
// 性别，1男性，2女性
private Integer sex;
// 出生日期
private Date birthday;
// 创建时间
private Date created;
// 更新时间
private Date updated;
// 备注
private String note;
}

步骤五:对 UserService 的代码进行简单改造

@Service
public class UserService {
@Autowired
private UserMapper userMapper;
public User queryById(Long id){
//根据id查询
return userMapper.selectByPrimaryKey(id);
}
@Transactional
public void saveUser(User user){
System.out.println("新增用户…");
userMapper.insertSelective(user);
}
}

步骤六：启动测试，将 HelloController 进行简单改造：

@RestController
public class HelloController {
@Autowired
private UserService userService;
/**
* 根据id获取用户
* @param id 用户id
* @return 用户
*/
@GetMapping("/user/{id}")
public User queryById(@PathVariable Long id){
return userService.queryById(id);
}
}