高级框架-SpringBoot【悟空教程】

2018-08-16 15:55:23 浏览数 (1)

Spring Boot

第1章 Spring Boot 简介

Spring 诞生时是 Java 企业版（Java Enterprise Edition，JEE，也称 J2EE）的轻量级代替品。无需开发重量级的 Enterprise JavaBean（EJB），Spring 为企业级 Java 开发提供了一种相对简单的方法，通过依赖注入和面向切面编程，用简单的 Java 对象（Plain Old Java Object，POJO）实现了 EJB 的功能。

虽然 Spring 的组件代码是轻量级的，但它的配置却是重量级的。

第一阶段：xml 配置

在 Spring 1.x 时代，使用 Spring 开发满眼都是 xml 配置的 Bean，随着项目的扩大，我们需要把 xml配置文件放到不同的配置文件里，那时需要频繁的在开发的类和配置文件之间进行切换

第二阶段：注解配置

在 Spring 2.x 时代，随着 JDK1.5 带来的注解支持，Spring 提供了声明 Bean 的注解（例如@Component、@Service），大大减少了配置量。主要使用的方式是应用的基本配置（如数据库配置）用 xml，业务配置用注解

第三阶段：java 配置

Spring 3.0 引入了基于 Java 的配置能力，这是一种类型安全的可重构配置方式，可以代替 XML。我们目前刚好处于这个时代，Spring4.x 和 Spring Boot 都推荐使用 Java 配置。

所有这些配置都代表了开发时的损耗。 因为在思考 Spring 特性配置和解决业务问题之间需要进行思维切换，所以写配置挤占了写应用程序逻辑的时间。除此之外，项目的依赖管理也是件吃力不讨好的事情。决定项目里要用哪些库就已经够让人头痛的了，你还要知道这些库的哪个版本和其他库不会有冲突，这难题实在太棘手。并且，依赖管理也是一种损耗，添加依赖不是写应用程序代码。一旦选错了依赖的版本，随之而来的不兼容问题毫无疑问会是生产力杀手。

Spring Boot 让这一切成为了过去。

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

我们可以使用 SpringBoot 创建 java 应用，并使用 java –jar 启动它，或者采用传统的 war 部署方式。

Spring Boot 主要目标是：

为所有 Spring 的开发提供一个从根本上更快的入门体验

开箱即用，但通过自己设置参数，即可快速摆脱这种方式。

提供了一些大型项目中常见的非功能性特性，如内嵌服务器、安全、指标，健康检测、外部化配置等

绝对没有代码生成，也无需 XML 配置。

第2章 Spring Boot 入门

2.1 环境搭建

2.1.1 环境需求

数据库：MySQL

IDE：Eclipse Mars2

Spring-Boot：1.4.4

Maven： 3.3.3 （官方声明 1.4.4 版本需要 Maven 3.2 ）

本地仓库：需要使用资料中的仓库

2.1.2 创建一个 Maven 工程并添加起步依赖

添加依赖

在 pom.xml 中添加依赖，效果如下

代码语言：javascript复制
<parent> 
<groupId>org.springframework.boot</groupId> 
<artifactId>spring-boot-starter-parent</artifactId> 
<version>1.4.4.RELEASE</version> 
</parent> 
<groupId>cn.com.javahelp.springboot</groupId> 
<artifactId>javahelp-springboot</artifactId> 
<version>0.0.1-SNAPSHOT</version> 
<dependencies> 
<dependency> 
<groupId>org.springframework.boot</groupId> 
<artifactId>spring-boot-starter-web</artifactId> 
</dependency> 
</dependencies>

我们会惊奇地发现，我们的工程自动添加了好多好多 jar 包，而这些 jar 包正式我们做开发时需要导入的jar 包。

因 为 这 些 jar 包 被 我 们 刚 才 加 入 的 spring-boot-starter-web 所 引 用 了 ， 所 以 添 加spring-boot-starter-web 后会自动把依赖传递过来。

2.1.3 变更 JDK 版本(如果做了 maven 全局配置可略过此步)

我们发现默认情况下工程的 JDK 版本是 1.6，但是通常使用的是 1.7 的版本

修改 JDK 为 1.7，需要在 pom.xml 中添加以下配置：

代码语言：javascript复制
<properties>
<java.version>1.7</java.version>
</properties>

使用 Maven 更新工程后，就发现版本已经变成 1.8 了

注意：

虽然 JDK1.6 或者 1.7 都可以使用 Spring-Boot，但 Spring-Boot 官方建议使用 JDK1.8。要使用JDK1.8，首先必须要配置 JDK1.8 后，才可以使用上述方法设置。

2.1.4 编写引导类并使用注解配置

需要创建一个引导类：

代码语言：javascript复制
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication; 
@SpringBootApplication 
public class Demo {
public static void main(String[] args) { 
SpringApplication.run(Demo.class, args); 
} 
}

这里多了一个@SpringBootApplication 注解

@Configuration： 用于定义一个配置类

@EnableAutoConfiguration ：Spring Boot 会自动根据你 jar 包的依赖来自动配置项目。

@ComponentScan： 告诉 Spring 哪个 packages 的用注解标识的类会被 spring

自动扫描并且装入 bean 容器。

Banner

直接启动，控制台出现以下标识。

这个标识是 Spring 启动标识，如果不想要，可以设置取消

代码语言：javascript复制
import org.springframework.boot.Banner.Mode; 
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication; 
@SpringBootApplication 
public class Application { 
public static void main(String[] args) { 
// SpringApplication.run(Application.class, args);
SpringApplication application = new SpringApplication(Application.class);
application.setBannerMode(Mode.OFF);
application.run(args);
} 
}

参考附录二的 banner 设置，可以通过修改配置文件制定自己的标识。

2.1.5 测试环境搭建结果

在地址栏输入：http://localhost:8080，看到下图即表示搭建成功

2.2 入门程序

2.2.1 需求

使用 Spring MVC 和 Spring Boot 整合实现浏览器输出 Hello Spring Boot!

2.2.2 原来的实现

我们现在开始使用 spring MVC 框架，实现 json 数据的输出。如果按照我们原来的做法，需要在 web.xml 中添加一个 DispatcherServlet 的配置，还需要添加一个 spring 的配置文件，配置文件如下配置

spring 加入配置

代码语言：javascript复制
<!-- controller 注解扫描 -->
<context:component-scan base-package="cn.com.javahelp.springboot.controller" /> 
<!-- 注解驱动 -->
<mvc:annotation-driven /> 
web.xml 加入配置 
<!-- 配置前端控制器 -->
<servlet> 
<servlet-name> javahelp-springboot</servlet-name> 
<servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class> 
<init-param> 
<param-name>contextConfigLocation</param-name> 
<param-value>classpath:spring/*.xml</param-value>
</init-param> 
</servlet>
<servlet-mapping> 
<servlet-name> javahelp-springboot</servlet-name> 
<url-pattern>/</url-pattern> 
</servlet-mapping>

还要编写 Controller。。。

2.2.3 Spring-Boot 的实现

我们不需要配置文件，直接编写 Controller 类即可

代码语言：javascript复制
import org.springframework.web.bind.annotation.RequestMapping; 
import org.springframework.web.bind.annotation.RestController; 
@RestController 
public class HelloWorldController { 
@RequestMapping("hello") 
public String info() { 
return "Hello Spring Boot!"; 
} 
}

@RestController 注解:

其实就是@Controller 和@ResponseBody 注解加在一起

启动方式一：启动之前编写的引导类即可

启动方式二：使用 Maven 命令 spring-boot:run 执行即可

选择 Maven Build

在浏览器地址栏输入 http://localhost:8080/hello 即可看到运行结果

2.3 热部署

我们在开发中反复修改类、页面等资源，每次修改后都是需要重新启动才生效，这样每次启动都很麻烦，浪费了大量的时间。

能不能在我修改代码后不重启就能生效呢？可以，由于 Spring Boot 应用只是普通的 Java 应用，所以 JVM热交换（hot-swapping）也能开箱即用。不过 JVM 热交换能替换的字节码有限制，想要更彻底的解决方案可以使用 Spring Loaded 项目或 JRebel。 spring-boot-devtools 模块也支持应用快速重启(restart)。

2.3.1 导入 maven 依赖

我们只需要在 pom.xml 加入如下配置即可

代码语言：javascript复制
<dependency> 
<groupId>org.springframework.boot</groupId> 
<artifactId>spring-boot-devtools</artifactId> 
</dependency>

2.3.2 在 eclipse 中配置启动参数

-javaagent:E:/MavenRepository/org/springframework/springloaded/1.2.9/springloaded-1.2.9.jar -noverify

2.3.3 特殊说明

在 spring5.x 时，必须使用 springloaded 最新版 1.2.9。因为 spring5.x 采用的是 1.8 为内核编写的。而springloaded1.2.9 以前的版本都不支持 spring5.x。

这个 jar 包需无法通过在 pom.xml 中导入依赖自动下载。需要我们自己下载并且手动安装到 maven 仓库。

maven 命令:

首先通过 cmd 窗口进入到 jar 所在目录，然后拷贝下面的命令到控制台。回车运行。

mvn install:install-file -DgroupId=org.springframework -DartifactId=springloaded -Dversion=1.2.9 -Dpackaging=jar -Dfile=springloaded-1.2.9.BUILD.jar

注意：

安装 jar 包时,jar 存放目录最好别有中文和空格。

第3章 SpringBoot 整合

3.1 整合 Spring Data JPA

3.1.1 需求

使用 Spring Boot Spring MVC Spring Data JPA EasyUI 框架组合实现部门列表查询，效果如下：

3.1.2 环境准备

3.1.2.1 导入数据库表

在 MySQL 数据库执行以下语句

代码语言：javascript复制
DROP TABLE IF EXISTS `user`; 
CREATE TABLE `user` ( 
`id` bigint(20) NOT NULL AUTO_INCREMENT, 
`user_name` varchar(100) DEFAULT NULL COMMENT \'用户名\',
`password` varchar(100) DEFAULT NULL COMMENT \'密码\', 
`name` varchar(100) DEFAULT NULL COMMENT \'姓名\', 
PRIMARY KEY (`id`) 
) ENGINE=InnoDB AUTO_INCREMENT=7 DEFAULT CHARSET=utf8;
INSERT INTO `user` VALUES (\'1\', \'zhangsan\', \'123456\', \'张三\');
INSERT INTO `user` VALUES (\'2\', \'lisi\', \'123456\', \'李四\');
INSERT INTO `user` VALUES (\'3\', \'wangwu\', \'123456\', \'王五\'); 
INSERT INTO `user` VALUES (\'4\', \'zhangwei\', \'123456\', \'张伟\');
INSERT INTO `user` VALUES (\'5\', \'lina\', \'123456\', \'李娜\');
INSERT INTO `user` VALUES (\'6\', \'lilei\', \'123456\', \'李磊\');
3.1.2.2 创建 Maven 工程
代码语言：javascript复制
javahelp-info(打 jar 包)，在 pom.xml 中进行如下配置 
<parent> 
<groupId>org.springframework.boot</groupId> 
<artifactId>spring-boot-starter-parent</artifactId> 
<version>1.4.4.RELEASE</version> 
</parent>
<dependencies>
<dependency>
<groupId>org.springframework.boot</groupId> 
<artifactId>spring-boot-starter-web</artifactId> 
<version>1.4.4.RELEASE</version>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId> 
<artifactId>spring-boot-devtools</artifactId>
<version>1.4.4.RELEASE</version>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId> 
<artifactId>spring-boot-starter-data-jpa</artifactId>
<version>1.4.4.RELEASE</version>
</dependency>
<dependency>
<groupId>mysql</groupId>
<artifactId>mysql-connector-java</artifactId>
<version>5.1.6</version>
</dependency>
</dependencies>
3.1.2.3 加入 Spring-Boot 配置文件
代码语言：javascript复制
在 src/main/resources 下添加 application.properties 配置文件，内容如下： 
#DB Configuration: 
spring.datasource.driverClassName=com.mysql.jdbc.Driver 
spring.datasource.url=jdbc:mysql://127.0.0.1:3306/taotao 
spring.datasource.username=root 
spring.datasource.password=root 
#JPA Configuration:
spring.jpa.database=MySQL 
spring.jpa.show-sql=true
spring.jpa.generate-ddl=true 
spring.jpa.hibernate.ddl-auto=update 
spring.jpa.hibernate.naming_strategy=org.hibernate.cfg.ImprovedNamingStrategy 
此文件用于覆盖 Spring Boot 的默认配置，完整的配置信息参考“附录 2”

3.1.3 后端实现

3.1.3.1 创建实体类
代码语言：javascript复制
import javax.persistence.Entity; 
import javax.persistence.Id; 
@Entity 
public class User { 
@Id 
private Long id; 
private String userName; 
private String password; 
private String name; 
//添加 get 和 set 方法 
}
3.1.3.2 创建 DAO 接口
代码语言：javascript复制
import org.springframework.data.jpa.repository.JpaRepository; 
import cn.com.javahelp.info.pojo.User; 
public interface UserDao extends JpaRepository<User, Long> { 
}
3.1.3.3 创建业务逻辑接口
代码语言：javascript复制
import java.util.List; 
import cn.com.javahelp.info.pojo.User; 
public interface UserService { 
List<User> findAll(); 
}
3.1.3.4 创建业务逻辑实现类
代码语言：javascript复制
import java.util.List; 
import org.springframework.beans.factory.annotation.Autowired; 
import org.springframework.stereotype.Service; 
import cn.com.javahelp.info.dao.UserDao; 
import cn.com.javahelp.info.pojo.User; 
import cn.com.javahelp.info.service.UserService; 
@Service 
public class UserServiceImpl implements UserService { 
@Autowired 
private UserDao userDao; 
@Override 
public List<User> findAll() { 
List<User> list = this.userDao.findAll(); 
return list; 
} 
}
3.1.3.5 创建 Controller
代码语言：javascript复制
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 cn.com.javahelp.info.pojo.User; 
import cn.com.javahelp.info.service.UserService; 
@RestController 
@RequestMapping("user") 
public class UserControlelr { 
@Autowired 
private UserService userService; 
@RequestMapping("list") 
public List<User> queryUserAll() { 
List<User> list = this.userService.findAll(); 
return list; 
} 
}
3.1.3.6 创建引导类
代码语言：javascript复制
import org.springframework.boot.SpringApplication; 
import org.springframework.boot.autoconfigure.SpringBootApplication; 
@SpringBootApplication 
public class Application { 
public static void main(String[] args) { 
SpringApplication.run(Application.class, args); 
} 
}

运行引导类 Application，打开浏览器输入 http://127.0.0.1:8080/user/list

3.1.4 前端实现

把资料中的 static 文件夹，拷贝到 src/main/resources 路径下

浏览器地址栏输入：http://127.0.0.1:8080/user.html，效果如下

运行引导类 Application

3.2 整合 MyBatis

3.2.1 加入依赖

代码语言：javascript复制
在 pom.xml 中加入以下依赖 
<!-- SpringBoot 的 Mybatis 启动器 -->
<dependency>
<groupId>org.mybatis.spring.boot</groupId>
<artifactId>mybatis-spring-boot-starter</artifactId> 
<version>1.1.1</version>
</dependency>
3.2.2 编写 Mapper 
和之前的方式一样，只是多了两个注解 
@Mapper：声明 Mapper 接口 
@Select：声明这个接口所需要使用的 sql，当然，有查询的注解，肯定就有增删改的注解。 
import java.util.List; 
import org.apache.ibatis.annotations.Mapper; 
import org.apache.ibatis.annotations.Select; 
import cn.com.javahelp.info.pojo.User; 
@Mapper 
public interface UserMapper { 
@Select("select * from user where name like \'%${value}%\'") 
public List<User> queryUserByName(String name);
}

3.2.3 编写 Service 和 Controller

代码语言：javascript复制
添加 Service 调用 Mapper 
@Service 
public class UserServiceImpl implements UserService { 
@Autowired
private UserDao userDao; 
@Autowired
private UserMapper userMapper; 
@Override 
public List<User> findAll() { 
List<User> list = this.userDao.findAll(); 
return list; 
} 
@Override 
public List<User> queryUserByName(String name) { 
List<User> list = this.userMapper.queryUserByName(name); 
return list; 
} 
} 
修改 Controller 
@RestController 
@RequestMapping("user") 
public class UserControlelr { 
@Autowired
private UserService userService; 
@RequestMapping("list")
public List<User> queryUserAll() { 
List<User> list = this.userService.findAll();
return list; 
} 
@RequestMapping("list/{name}") 
public List<User> queryUserAll(@PathVariable String name) { 
List<User> list = this.userService.queryUserByName(name); 
return list; 
} 
}

3.2.4 测试

浏览器地址栏输入：http://127.0.0.1:8080/user/list/张

显示效果：

3.3 整合 Redis

3.3.1 注解方式实现添加缓存

需求：基于上例代码，将列表数据缓存到 Redis

3.3.2 加入依赖

在 pom.xml 加入依赖

代码语言：javascript复制
<!-- 配置使用 redis 启动器 --> 
<dependency> 
<groupId>org.springframework.boot</groupId> 
<artifactId>spring-boot-starter-redis</artifactId> 
</dependency>
3.3.2.1 修改引导类

修改开启缓存，添加注解@EnableCaching

代码语言：javascript复制
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication; 
import org.springframework.cache.annotation.EnableCaching;
@SpringBootApplication 
@EnableCaching
public class Application { 
public static void main(String[] args) { 
SpringApplication.run(Application.class, args); 
} 
}
3.3.2.2 设置实现序列化接口

需要修改实体，让实体实现序列化接口

代码语言：javascript复制
@Entity 
public class User implements Serializable { 
@Id
private Long id; 
private String userName; 
private String password; 
private String name;
。。。。。。 
} 
3.3.2.3 实现添加/删除缓存 
修改 UserServiceImpl，添加@Cacheable 注解实现缓存添加 
@Override
@Cacheable(value = "userCache", key = "\'user.findAll\'") 
public List<User> findAll() { 
System.out.println("从 Mysql 中查询"); 
List<User> list = this.userDao.findAll(); 
return list;
} 
@Override
@CacheEvict(value = "userCache", ,allEntries=true) 
public List<User> queryUserByName(String name) {
System.out.println("缓存清理了！"); 
List<User> list = this.userMapper.queryUserByName(name); 
return list;
}

这 样 设 置 完 成 后 ， 执 行 findAll() 方 法 就 会 使 用 缓 存 ， 如 果 缓 存 没 有 就 添 加 缓 存 ， 而queryUserByName(String name)方法则是删除缓存

@Cacheable：添加/使用缓存

@CacheEvict：删除缓存

属性 value 是缓存的名字，在执行的时候，会找叫这个名字的缓存使用/删除

属性 key 默认情况下是空串””,是 Spring 的一种表达式语言 SpEL，我们这里可以随意指定，但是需要注意一定要加单引号

属性 allEntries 指定是否清空整个缓存区。

3.4 整合 junit

3.4.1 加入依赖

代码语言：javascript复制
在 pom.xml 中加入测试依赖 
<!-- 配置测试启动器 --> 
<dependency> 
<groupId>org.springframework.boot</groupId> 
<artifactId>spring-boot-starter-test</artifactId> 
<scope>test</scope> 
</dependency> 
3.4.2 编写测试类 
/** 
* <p>Title: SpringBootTest</p> 
* <p>Description: </p> 
* <p>Company: http://www.javahelp.com.cn/ </p>  
*/ 
@RunWith(SpringJUnit4ClassRunner.class) 
@SpringBootTest(classes=ApplicationRunner.class) 
public class SpringBootJunitTest { 
@Autowired 
private IUserService userService; 
@Test 
public void test1() { 
List<User> users = userService.findAll(); 
for(User user : users) { 
System.out.println(user); 
}
} 
} 
SpringRunner 与 SpringJUnit4ClassRunner 是继承关系，但是没有不同的地方，只是看起来子类SpringRunner 要短一些而已。 
@SpringBootTest 注解的 class 属性要指定引导类的 class

第4章 Spring Boot 深入学习

4.1 读取配置文件

4.1.1 读取核心配置文件

代码语言：javascript复制
/** 
* <p>Title: SpringBootTest</p> 
* <p>Description: 读取配置文件</p> 
* <p>Company: http://www.javahelp.com.cn/ </p>  
*/ 
@RunWith(SpringJUnit4ClassRunner.class) 
@SpringBootTest(classes=ApplicationRunner.class) 
public class ConfigFileTest { 
@Resource 
private Environment env; 
/** 
* 读取核心配置文件 
*/ 
@Test 
public void test1() { 
System.out.println(env.getProperty("spring.datasource.username")); 
System.out.println(env.getProperty("spring.datasource.password")); 
} 
}

4.1.2 读取自定义文件

在工程的 src/main/resources 下构建自定义配置文件 mail.properties, 内容如下

代码语言：javascript复制
mail.host=smtp.sina.com 
mail.port=25 
mail.username=javahelp 
mail.password=wukong
/** 
* <p>Title: MailProperties</p> 
* <p>Description: </p> 
* <p>Company: http://www.javahelp.com.cn/ </p>  
*/ 
@Configuration 
@PropertySource(value="classpath:mail.properties") 
@ConfigurationProperties(prefix="mail",ignoreUnknownFields = false) 
public class MailProperties { 
private String host;//smtp.sina.com 
private String port;//=25 
private String username;//=javahelp 
private String password;//=wukong 
public String getHost() { 
return host; 
} 
public void setHost(String host) { 
this.host = host; 
} 
public String getPort() { 
return port; 
} 
public void setPort(String port) { 
this.port = port; 
} 
public String getUsername() { 
return username; 
} 
public void setUsername(String username) { 
this.username = username; 
} 
public String getPassword() { 
return password; 
} 
public void setPassword(String password) { 
this.password = password; 
} 
@Override 
public String toString() { 
return "MailProperties [host="   host   ", port="   port   ", username="   username   ", password="   password   "]"; 
} 
}
/** 
* <p>Title: SpringBootTest</p> 
* <p>Description: 读取配置文件</p> 
* <p>Company: http://www.javahelp.com.cn/ </p>  
*/ 
@RunWith(SpringJUnit4ClassRunner.class) 
@SpringBootTest(classes=ApplicationRunner.class) 
public class ConfigFileTest { 
@Autowired 
private MailProperties mailProperties; 
/** 
* 读取自定义配置文件 
*/ 
@Test 
public void test2() { 
System.out.println(mailProperties); 
} 
}

4.1.3 读取 yml 文件

YML 文件格式是 YAML (YAML Aint Markup Language)编写的文件格式，YAML 是一种直观的能够被电脑识别的的数据数据序列化格式，并且容易被人类阅读，容易和脚本语言交互的，可以被支持 YAML 库的不同的编程语言程序导入，比如： C/C , Ruby, Python, Java, Perl, C#, PHP 等。YML 文件是以数据为核心的，比传统的 xml 方式更加简洁。

YML 文件的扩展名可以使用.yml 或者.yaml。

在 maven 工程中 yml 文件创建的位置是：

4.1.3.1 语法格式：

普通数据：

key：value

在 key 和 value 中必须有一个空格

对象数据：

mail:

host: smtp.sina.com

port: 25

username: javahelp

password: wukong

4.1.3.2 获取方式

yml 文件为：

第一种：使用@Value 注解配合 Spring 的 EL 表达式

@Value("${mail.host}")

private String mailHost;

第二种方式：使用@ConfigurationProperties 注解

代码语言：javascript复制
/** 
* <p>Title: Mailyml</p> 
* <p>Description: </p> 
* <p>Company: http://www.javahelp.com.cn/ </p>  
*/ 
@Configuration 
@ConfigurationProperties(prefix="mail") 
public class Mailyml implements Serializable { 
private String host; 
private String port; 
private String username; 
private String password; 
public String getHost() { 
return host; 
} 
public void setHost(String host) { 
this.host = host; 
} 
public String getPort() { 
return port; 
} 
public void setPort(String port) { 
this.port = port; 
} 
public String getUsername() { 
return username; 
} 
public void setUsername(String username) { 
this.username = username; 
} 
public String getPassword() { 
return password; 
} 
public void setPassword(String password) { 
this.password = password; 
} 
@Override 
public String toString() { 
return "Mailyml [host="   host   ", port="   port   ", username="   username   ", password="   password   "]"; 
} 
}
测试代码： 
/** 
* 读取自定义配置文件 
*/ 
@Test 
public void test3() { 
System.out.println(mailYml); 
System.out.println(mailHost); 
}

运行结果：

第5章 附录 1. Spring-boot 的启动器

(摘自 Spring-boot 1.4.4 官方文档)

1. Spring Boot application starters

spring-boot-starter-thymeleaf

使用 Thymeleaf 视图构建 MVC Web 应用程序

spring-boot-starter-ws

使用 Spring Web 服务。1.4 不推荐使用，推荐使用 spring-boot-starter-web-services

spring-boot-starter-data-couchbase

Starter for using Couchbase document-oriented database and Spring Data Couchbase

spring-boot-starter-artemis

使用 Apache Artemis 启动 JMS 消息传递

spring-boot-starter-web-services

使用 Spring Web 服务

spring-boot-starter-mail

支持使用 Java Mail 和 Spring Framework 发送电子邮件

spring-boot-starter-data-redis

使用 Redis 键值数据存储与 Spring Data Redis 和 Jedis 客户端

spring-boot-starter-web

启动器构建 web，包括 RESTful，使用 Spring MVC 的应用程序。使用 Tomcat 作为默认嵌入式容器

spring-boot-starter-data-gemfire

Starter for using GemFire distributed data store and Spring Data GemFire

spring-boot-starter-activemq

使用 Apache ActiveMQ 启动 JMS 消息传递

spring-boot-starter-data-elasticsearch

使用 Elasticsearch 搜索和分析引擎和 Spring Data Elasticsearch

spring-boot-starter-integration

Starter for using Spring Integration

spring-boot-starter-test

Spring Boot 应用程序用于测试包括 JUnit，Hamcrest 和 Mockito

spring-boot-starter-hornetq

使用 HornetQ 启动 JMS 消息传递。1.4 已弃用，推荐使用 spring-boot-starter-artemis

spring-boot-starter-jdbc

使用 JDBC 与 Tomcat JDBC 连接池

spring-boot-starter-mobile

使用 Spring Mobile 构建 Web 应用程序的入门

spring-boot-starter-validation

使用 Java Bean 校验与 Hibernate 校验器

spring-boot-starter-hateoas

使用 Spring MVC 和 Spring HATEOAS 构建基于超媒体的 RESTful Web 应用程序的入门

spring-boot-starter-jersey

使用 JAX-RS 和 Jersey 构建 RESTful Web 应用程序的入门。 spring-boot-starter-web 的替代品

spring-boot-starter-data-neo4j

使用 Neo4j 图数据库和 Spring Data Neo4j

spring-boot-starter-websocket

使用 Spring Framework 的 WebSocket 支持构建 WebSocket 应用程序

spring-boot-starter-aop

使用 Spring AOP 和 AspectJ 进行面向方面编程

spring-boot-starter-amqp

使用 Spring AMQP 和 Rabbit MQ 的入门

spring-boot-starter-data-cassandra

使用 Cassandra 分布式数据库和 Spring Data Cassandra

spring-boot-starter-social-facebook

使用 Spring Social Facebook

spring-boot-starter-jta-atomikos

使用 Atomikos 进行 JTA 事务

spring-boot-starter-security

使用 Spring Security

spring-boot-starter-mustache

使用 Mustache 视图构建 MVC Web 应用程序

spring-boot-starter-data-jpa

使用 Spring Data JPA 与 Hibernate

spring-boot-starter

核心启动器，包括自动配置支持，日志记录和 YAML

spring-boot-starter-velocity

使用 Velocity 视图构建 MVC Web 应用程序。1.4 已弃用

spring-boot-starter-groovy-templates

使用 Groovy 模板视图构建 MVC Web 应用程序

spring-boot-starter-freemarker

使用 FreeMarker 视图构建 MVC Web 应用程序

spring-boot-starter-batch

使用 Spring Batch

spring-boot-starter-redis

使用 Redis 键值数据存储与 Spring Data Redis 和 Jedis 客户端的入门。1.4 已弃用，建议使用spring-boot-starter-data-redis

spring-boot-starter-social-linkedin

Stater for using Spring Social LinkedIn

spring-boot-starter-cache

支持使用 Spring Framework 的缓存

spring-boot-starter-data-solr

使用带有 Spring Data Solr 的 Apache Solr 搜索平台

spring-boot-starter-data-mongodb

使用 MongoDB 和 Spring Data MongoDB

spring-boot-starter-jooq

使用 jOOQ 访问 SQL 数据库。 spring-boot-starter-data-jpa 或 spring-boot-starter-jdbc 的替代方法

spring-boot-starter-jta-narayana

Spring Boot 启动 Narayana JTA

spring-boot-starter-cloud-connectors

启动者使用 Spring Cloud 连接器，简化了连接到云平台中的服务，如 Cloud Foundry 和 Heroku

spring-boot-starter-jta-bitronix

使用 Bitronix 进行 JTA 事务

spring-boot-starter-social-twitter

使用 Spring Social Twitter

spring-boot-starter-data-rest

使用 Spring Data REST 通过 REST 暴露 Spring 数据存储库

2. Spring Boot production starters

spring-boot-starter-actuator

使用 Spring Boot 的 Actuator，提供生产就绪的功能，以帮助您监视和管理您的应用程序

spring-boot-starter-remote-shell

使用 CRaSH 远程 shell 通过 SSH 监视和管理您的应用程序

3. Spring Boot technical starters

spring-boot-starter-undertow

使用 Undertow 作为嵌入式 servlet 容器。 spring-boot-starter-tomcat 的替代方法

spring-boot-starter-jetty

使用 Jetty 作为嵌入式 servlet 容器的。 spring-boot-starter-tomcat 的替代方法

spring-boot-starter-logging

使用 Logback 进行日志记录。 默认日志启动器

spring-boot-starter-tomcat

使用 Tomcat 作为嵌入式 servlet 容器。 spring-boot-starter-web 使用的默认 servlet 容器

spring-boot-starter-log4j2

使用 Log4j2 进行日志记录。 spring-boot-starter-logging 的替代方法

spring java erp

0 人点赞