springboot_springboot面试题 - CSDN
精华内容
参与话题
  • SpringBoot从入门到精通

    千人学习 2020-03-31 10:59:53
    SpringBoot是企业级开发的解决方案,同时也是我们微服务框架的基础。在现在企业项目开发中使用非常普遍,而且相对于Spring等框架前者上手更快一些,而且也容易一些。学习SpringBoot,玩转SpringBoot基本就能应对目前...
  • 超详细的springBoot学习笔记

    万次阅读 多人点赞 2019-05-06 13:34:42
    Spring Boot 1.Spring Boot简介 Spring诞生时是Java企业版(Java Enterprise Edition,JEE,也称J2EE)的 轻量级代替品。无需开发重量级的Enterprise JavaBean(EJB...Java开发提供了一种相...

     

     

     

     

    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 主要目标是:

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

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

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

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

    2. Spring Boot 入门

    2.1. 环境准备

    数据库:MySQL

    IDE:Eclipse Mars2

    Spring-Boot:1.4.4

    Maven: 3.3.3 (官方声明1.4.4版本需要Maven 3.2+)

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

    2.2. 起步依赖

    2.2.1. 创建一个Maven工程

    2.2.2. 添加依赖

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

    <parent>

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

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

    <version>1.4.4.RELEASE</version>

    </parent>

    <groupId>cn.cnn.springboot</groupId>

    <artifactId>cnn-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.3. 变更JDK版本

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

     

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

    <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.4. 引导类

    需要创建一个引导类:

    import org.springframework.boot.SpringApplication;

    import org.springframework.boot.autoconfigure.SpringBootApplication;

     

    @SpringBootApplication

    public class Demo {

     

    public static void main(String[] args) {

    SpringApplication.run(Demo.classargs);

    }

    }

     

    这里多了一个@SpringBootApplication注解

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

    @EnableAutoConfiguration :Spring Boot 会自动根据你jar 包的依赖来自动配置

    项目。

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

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

     

    Banner

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

      .   ____          _            __ _ _

     /\\ / ___'_ __ _ _(_)_ __  __ _ \ \ \ \

    ( ( )\___ | '_ | '_| | '_ \/ _` | \ \ \ \

     \\/  ___)| |_)| | | | | || (_| |  ) ) ) )

      '  |____| .__|_| |_|_| |_\__, | / / / /

     =========|_|==============|___/=/_/_/_/

     :: Spring Boot ::        (v1.4.4.RELEASE)

     

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

    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.5. 入门程序

    需求:使用Spring MVC实现Hello World输出

     

    2.5.1. 原来的实现

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

     

    spring加入配置

    <!-- controller注解扫描 -->

    <context:component-scan base-package="cn.cnn.springboot.controller" />

     

    <!-- 注解驱动 -->

    <mvc:annotation-driven />

     

    web.xml加入配置

    <!-- 配置前端控制器 -->

    <servlet>

    <servlet-namecnn-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-namecnn-springboot</servlet-name>

    <url-pattern>/</url-pattern>

    </servlet-mapping>

     

    还要编写Controller。。。

     

    2.5.2. Spring-Boot的实现

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

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

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

     

    @RestController

    public class HelloWorldController {

     

    @RequestMapping("info")

    public String info() {

    return "Hello world!";

    }

     

    }

     

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

     

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

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

    选择 Maven Build

     

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

     

    2.6. 热部署

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

     

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

     

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

    <dependency>

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

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

    </dependency>

     

    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数据库执行以下语句

    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工程

    cnn-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配置文件

    在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. 创建实体类

    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接口

    import org.springframework.data.jpa.repository.JpaRepository;

    import cn.cnn.info.pojo.User;

     

    public interface UserDao extends JpaRepository<User, Long> {

    }

     

    3.1.3.3. 创建业务逻辑接口

    import java.util.List;

    import cn.cnn.info.pojo.User;

     

    public interface UserService {

    List<User> findAll();

    }

     

    3.1.3.4. 创建业务逻辑实现类

    import java.util.List;

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

    import org.springframework.stereotype.Service;

    import cn.cnn.info.dao.UserDao;

    import cn.cnn.info.pojo.User;

    import cn.cnn.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

    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.cnn.info.pojo.User;

    import cn.cnn.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. 创建引导类

    import org.springframework.boot.SpringApplication;

    import org.springframework.boot.autoconfigure.SpringBootApplication;

     

    @SpringBootApplication

    public class Application {

    public static void main(String[] args) {

    SpringApplication.run(Application.classargs);

    }

     

    }

     

    运行引导类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. 简单整合

    3.2.1.1. 加入依赖

    在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.1.2. 编写Mapper

    和之前的方式一样,只是多了两个注解

    @Mapper:声明Mapper接口

    @Select:声明这个接口所需要使用的sql,当然,有查询的注解,肯定就有增删改的注解。

    import java.util.List;

    import org.apache.ibatis.annotations.Mapper;

    import org.apache.ibatis.annotations.Select;

    import cn.cnn.info.pojo.User;

     

    @Mapper

    public interface UserMapper {

     

    @Select("select * from user where name like '%${value}%'")

    public List<User> queryUserByName(String name);

     

    }

     

    3.2.1.3. 编写Service和Controller

    添加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.1.4. 测试

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

    显示效果:

     

    3.2.2. 整合通用Mapper和分页助手

    以上所有的配置都是使用的默认配置,我们只需要专注java代码的开发即可,不需要加入配置文件了。

     

    但并不是所有得场景都是简单的业务,有时候业务复杂,需要我们加入自定义的配置文件;有时候需要载入例如分页助手这样的插件,辅助开发,所以我们也需要了解如何加载这些配置。

     

    3.2.2.1. 加入依赖

    我们需要加入通用Mapper和分页插件,所以需要在pom.xml加入以下依赖

    <!-- 通用Mapper -->

    <dependency>

    <groupId>com.github.abel533</groupId>

    <artifactId>mapper</artifactId>

    <version>2.3.4</version>

    </dependency>

    <!-- 分页助手 -->

    <dependency>

    <groupId>com.github.pagehelper</groupId>

    <artifactId>pagehelper</artifactId>

    <version>3.7.5</version>

    </dependency>

    <dependency>

    <groupId>com.github.jsqlparser</groupId>

    <artifactId>jsqlparser</artifactId>

    <version>0.9.1</version>

    </dependency>

     

    3.2.2.2. 修改配置文件

    在application.properties添加配置

    #spring集成Mybatis环境

    #pojo别名扫描包

    mybatis.type-aliases-package=cn.cnn.info.pojo

    #加载Mybatis核心配置文件

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

    mybatis.config-location=classpath:mybatis/SqlMapConfig.xml

    #配置连接池,还需要在pom.xml中加入该连接池的依赖

    #spring.datasource.type=com.jolbox.bonecp.BoneCPDataSource

     

    在src\main\resources\mapper路径下加入UserMapper.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="cn.cnn.info.dao.UserMapper">

    <select id="queryAll" resultType="user">

    select * from user

    </select>

    </mapper>

     

    在src\main\resources\mybatis加入SqlMapConfig.xml配置文件,用以加载通用Mapper和分页助手

    <?xml version="1.0" encoding="UTF-8" ?>

    <!DOCTYPE configuration

      PUBLIC "-//mybatis.org//DTD Config 3.0//EN"

      "http://mybatis.org/dtd/mybatis-3-config.dtd">

    <configuration>

    <!-- 分页助手 -->

    <plugins>

    <plugin interceptor="com.github.pagehelper.PageHelper">

    <property name="dialect" value="mysql" />

    <!-- 该参数默认为false -->

    <!-- 设置为true时,使用RowBounds分页会进行count查询 -->

    <property name="rowBoundsWithCount" value="true" />

    </plugin>

     

    <!-- 通用Mapper -->

    <plugin interceptor="com.github.abel533.mapperhelper.MapperInterceptor">

    <!--主键自增回写方法,默认值MYSQL,详细说明请看文档 -->

    <property name="IDENTITY" value="MYSQL" />

    <!--通用Mapper接口,多个通用接口用逗号隔开 -->

    <property name="mappers" value="com.github.abel533.mapper.Mapper" />

    </plugin>

    </plugins>

    </configuration>

     

     

    3.2.2.3. 编写Mapper

    import java.util.List;

    import org.apache.ibatis.annotations.Mapper;

    import org.apache.ibatis.annotations.Select;

    import cn.cnn.info.pojo.User;

     

    //extends com.github.abel533.mapper.Mapper<User>:需要继承通用Mapper

    @Mapper

    public interface UserMapper extends com.github.abel533.mapper.Mapper<User> {

     

    @Select("select * from user where name like '%${value}%'")

    public List<User> queryUserByName(String name);

     

    // 使用UserMapper.xml配置文件

    public List<User> queryAll();

    }

     

    3.2.2.4. 编写Service和Controller

    Service编写

    import java.util.List;

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

    import org.springframework.stereotype.Service;

    import com.github.pagehelper.PageHelper;

    import cn.cnn.info.dao.UserDao;

    import cn.cnn.info.dao.UserMapper;

    import cn.cnn.info.pojo.User;

    import cn.cnn.info.service.UserService;

     

    @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;

    }

     

    // 调用使用UserMapper.xml的Mapper

    @Override

    public List<User> queryAll() {

    List<User> list = this.userMapper.queryAll();

    return list;

    }

     

    // 使用通用Mapper和分页助手

    @Override

    public List<User> queryUserByPage(Integer page, Integer rows) {

    // 设置分页

    PageHelper.startPage(pagerows);

    // 使用通用Mapper的方法进行查询所有数据

    List<User> list = this.userMapper.select(null);

    return list;

    }

    }

     

    Controller编写

    import java.util.List;

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

    import org.springframework.web.bind.annotation.PathVariable;

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

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

    import cn.cnn.info.pojo.User;

    import cn.cnn.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;

    }

     

    @RequestMapping("list/{name}")

    public List<User> queryUserAll(@PathVariable String name) {

    List<User> list = this.userService.queryUserByName(name);

    return list;

    }

     

    @RequestMapping("list/query")

    public List<User> queryUserAll2() {

    List<User> list = this.userService.queryAll();

    return list;

    }

     

    @RequestMapping("list/{page}/{rows}")

    public List<User> queryUserAll(@PathVariable Integer page@PathVariable Integer rows) {

    List<User> list = this.userService.queryUserByPage(pagerows);

    return list;

    }

     

    }

     

    3.2.2.5. 测试

    测试使用UserMapper.xml

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

     

    测试使用通用Mapper和分页助手

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

     

    3.3. 整合Redis

    3.3.1. 注解方式实现添加缓存

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

    3.3.1.1. 加入依赖

    在pom.xml加入依赖

    <!-- 配置使用redis启动器 -->

    <dependency>

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

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

    </dependency>

     

    3.3.1.2. 修改引导类

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

    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.classargs);

    }

     

    }

     

    3.3.1.3. 设置实现序列化接口

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

    @Entity

    public class User implements Serializable {

    @Id

    private Long id;

    private String userName;

    private String password;

    private String name;

     

    。。。。。

    }

     

    3.3.1.4. 实现添加/删除缓存

    修改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", key = "'user.findAll'")

    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,我们这里可以随意指定,但是需要注意一定要加单引号

     

    3.3.2. redis的深入使用

    3.3.2.1. 直接操作redis

    redis除了作为缓存使用,还有很多其他的作用,例如利用redis的单线程获取唯一数,例如使用redis为单点登录系统存储用户登录信息等,我们就需要直接操作redis。

     

    官网提供了三种接口RedisConnectionFactory, StringRedisTemplate 和 RedisTemplate,我们可以直接注入或者自己实现其他的实现类,来直接操作redis。我们这里使用RedisTemplate来操作Redis。

     

    如下所示,我们只需要直接注入RedisTemplate即可使用以下方法操作redis的五种不同的数据类型

     

     

    测试:

    @Autowired

    private RedisTemplate<String, String> redisTemplate;

     

    @Override

    @CacheEvict(value = "userCache", key = "'user.findAll'")

    public List<User> queryUserByName(String name) {

    // 保存数据

    this.redisTemplate.boundValueOps("redis").set("Hello redis !");

    // 设置有效时间为100秒

    this.redisTemplate.boundValueOps("redis").expire(100l, TimeUnit.SECONDS);

    // 给value每次执行加一操作

    this.redisTemplate.boundValueOps("count").increment(1l);

     

    System.out.println("缓存清理了!");

    List<User> list = this.userMapper.queryUserByName(name);

    return list;

    }

     

    3.3.2.2. 设置redis连接属性

    redis单机版

    redis启动器默认情况下会找本地的redis服务,端口号默认是6379如果需要访问其他服务器的redis,则需要在application.properties中进行如下配置:

    #Redis

    spring.redis.host=192.168.37.161

    spring.redis.port=6379

    这表示会去找ip为192.168.37.161和端口为6379的服务

     

    redis集群版

    #Redis

    #spring.redis.host=192.168.37.161

    #spring.redis.port=6379

     

    #Redis Cluster

    spring.redis.cluster.nodes=192.168.37.161:7001,192.168.37.161:7002,192.168.37.161:7003,192.168.37.161:7004,192.168.37.161:7005,192.168.37.161:7006

    切换到集群版只需要做以上配置,配置集群版节点信息,注释掉单机版信息

     

    3.4. 整合ActiveMQ

    3.4.1. 加入依赖

    在pom.xml中加入以下配置

    <!-- 配置ActiveMQ启动器 -->

    <dependency>

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

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

    </dependency>

     

    3.4.2. 创建队列

    在引导类中添加以下方法,设置队列

    @SpringBootApplication

    @EnableCaching

    public class Application {

    public static void main(String[] args) {

    SpringApplication.run(Application.classargs);

    }

     

    @Bean

    public Queue queue() {

    return new ActiveMQQueue("cnn.queue");

    }

     

    }

     

    3.4.3. 发送消息

    编写Controller,发送消息

    import javax.jms.Destination;

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

    import org.springframework.jms.core.JmsTemplate;

    import org.springframework.web.bind.annotation.PathVariable;

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

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

     

    @RestController

    @RequestMapping("queue")

    public class QueueController {

     

    //注入发送消息的对象

    @Autowired

    private JmsTemplate jmsTemplate;

     

    //注入消息队列

    @Autowired

    private Destination destination;

     

    //编写发送消息的方法

    @RequestMapping("send/{message}")

    public String send(@PathVariable String message) {

    this.jmsTemplate.convertAndSend(destinationmessage);

    return "消息发送成功!消息内容:" + message;

    }

     

    }

     

    3.4.4. 接收消息

    编写bean,加入@Component注解让spring管理这个bean,作为接收消息的消费者

    import org.springframework.jms.annotation.JmsListener;

    import org.springframework.stereotype.Component;

     

    @Component

    public class Consumer {

     

    // 接受消息方法

    @JmsListener(destination = "cnn.queue")

    public void readMessage(String text) {

    System.out.println("接受到的消息是:" + text);

    }

    }

     

    测试:

    启动服务后,在浏览器执行http://127.0.0.1:8080/queue/send/发消息了11

    即可看到消息发送成功

    同时可以在控制台看到打印信息

     

    我们没有安装ActiveMQ,为什么可以使用?因为Spring Boot 内置了ActiveMQ 的服务,所以我们不用单独启动也可以实现消息的发送和接收。

     

    3.4.5. 使用外部服务

    首先确认有一台外部ActiveMQ服务可以使用

     

    在application.properties中加入以下配置

    #ActiveMQ

    spring.activemq.broker-url=tcp://192.168.37.161:61616

     

    这样就加入了ActiveMQ服务的地址

     

    3.5. 整合junit

    3.5.1. 加入依赖

    在pom.xml中加入测试依赖

    <!-- 配置测试启动器 -->

    <dependency>

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

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

    <scope>test</scope>

    </dependency>

     

    3.5.2. 编写测试类

    import javax.jms.Destination;

    import org.junit.Test;

    import org.junit.runner.RunWith;

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

    import org.springframework.boot.test.context.SpringBootTest;

    import org.springframework.jms.core.JmsTemplate;

    import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;

     

    import cn.cnn.info.Application;

     

    @RunWith(SpringJUnit4ClassRunner.class)

    @SpringBootTest(classes = Application.class)

    public class MessageTest {

     

    @Autowired

    private Destination destination;

     

    @Autowired

    private JmsTemplate jmsTemplate;

     

    @Test

    public void test() {

    System.out.println("我发消息了!");

    this.jmsTemplate.convertAndSend(destination"Hello ActiveMQ!");

    }

     

    }

    SpringRunner 与SpringJUnit4ClassRunner 是继承关系,但是没有不同的地方,只是看起来子类SpringRunner要短一些而已。

     

    @SpringBootTest 注解的class 属性要指定引导类的class

     

    3.6. 整合dubbox

    3.6.1. 环境准备

    3.6.1.1. dubbox

    dubbo是一个分布式的服务架构,可直接用于生产环境作为SOA服务框架。官网首页:http://dubbo.io/  

     

    淘宝将这个项目开源出来以后,得到了不少同行的支持,包括:

    当当网的扩展版本dubbox :https://github.com/dangdangdotcom/dubbox

    京东的扩展版本jd-hydra: http://www.oschina.NET/p/jd-hydra

     

    不过,略有遗憾的是, dubbo由于某些原因导致dubbo团队已经解散,已经很牛没有更新了,反到是当当网的扩展版本仍在持续发展。因为dubbox支持更新的spring版本,所以我们使用dubbox。

     

    Dubbox在maven中央仓库并没有对应的依赖,所以我们需要自己动手将其发布到我们的本地仓库来使用。

     

    使用git从码云上把dubbox的代码clone下来,

    地址:https://git.oschina.net/wuyu15255872976/dubbox.git

     

    执行Maven命令把工程安装到本地仓库

    命令:clean install -Dmaven.test.skip

     

    课程资料提供的仓库已经安装好了,可以直接使用

     

    3.6.1.2. spring-boot-starter-dubbo

    我们以前在使用dubbo的时候都是用的xml配置。而在整合Spring Boot的时候可以使用@ImportResource注解来引入的dubbo的xml配置。

    但是Spring Boot本身并不推荐xml配置。怎么解决这个矛盾,我们可以自己准备一个Spring Boot Starter dubbo的项目来引导Spring Boot对Dubbo的自动化配置。已经有人开发好了这个自动化配置项目,我们直接使用就行了

     

    使用git从码云上把spring-boot-starter-dubbo的代码clone下来,

    地址:https://git.oschina.net/wuyu15255872976/spring-boot-starter-dubbo.git

     

    执行Maven命令把工程安装到本地仓库

    命令:clean install -Dmaven.test.skip

     

    为了统一管理,把pom.xml修改为如下:

    <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>1.4.4.RELEASE</version>

    </parent>

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

    <version>1.4.4.RELEASE</version>

    <name>Spring Boot Dubbo Rpc</name>

    <description>Spring Boot Dubbo Rpc</description>

    <url>http://projects.spring.io/spring-boot/</url>

    <organization>

    <name>Pivotal Software, Inc.</name>

    <url>http://www.spring.io</url>

    </organization>

    <properties>

    <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>

    <java.version>1.7</java.version>

    </properties>

     

        <dependencies>

    <dependency>

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

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

    </dependency>

    <dependency>

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

    <artifactId>spring-boot-configuration-processor</artifactId>

    </dependency>

    <dependency>

    <groupId>com.alibaba</groupId>

    <artifactId>dubbo</artifactId>

    <version>2.8.5-SNAPSHOT</version>

    <exclusions>

    <exclusion>

    <artifactId>spring</artifactId>

    <groupId>org.springframework</groupId>

    </exclusion>

    </exclusions>

    </dependency>

    <!-- zookeeper 客户端 -->

    <dependency>

    <groupId>com.github.sgroschupf</groupId>

    <artifactId>zkclient</artifactId>

    <version>0.1</version>

    </dependency>

    </dependencies>

    <dependencyManagement>

    <dependencies>

    <dependency>

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

    <artifactId>spring-boot-dependencies</artifactId>

    <version>1.4.4.RELEASE</version>

    <type>pom</type>

    <scope>import</scope>

    </dependency>

    </dependencies>

    </dependencyManagement>

     

    <build>

    <plugins>

    <plugin>

    <artifactId>maven-source-plugin</artifactId>

    <configuration>

    <attach>true</attach>

    </configuration>

    <executions>

    <execution>

    <phase>compile</phase>

    <goals>

    <goal>jar</goal>

    </goals>

    </execution>

    </executions>

    </plugin>

    </plugins>

    </build>

    </project>

     

    课程资料提供的仓库已经安装好了,可以直接使用

     

    3.6.1.3. zookeeper注册中心

    我们使用zookeeper作为dubbo的注册中心。

    这里使用的zookeeper注册中心地址是:192.168.37.161:2181

    修改hosts,配置注册中心的域名是zookeeper.taotao.com

     

    3.6.2. 搭建项目

    taotao-parent作为所有工程的父工程

    taotao- interface作为提供pojo和抽取服务接口的

    taotao-provider作为服务提供者

    taotao-consumer作为服务消费者

     

    3.6.2.1. 搭建taotao-parent

    创建taotao-parent,并打pom包,这里配置公共使用的依赖。

    修改pom.xml为如下

    <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>1.4.4.RELEASE</version>

    </parent>

    <groupId>com.taotao</groupId>

    <artifactId>taotao-parent</artifactId>

    <version>0.0.1-SNAPSHOT</version>

    <packaging>pom</packaging>

     

    <properties>

    <!-- 配置java版本 -->

    <java.version>1.7</java.version>

    </properties>

     

    <dependencies>

    <!-- 配置测试启动器 -->

    <dependency>

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

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

    <scope>test</scope>

    </dependency>

     

    <!-- 配置web启动器 -->

    <dependency>

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

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

    <optional>true</optional>

    </dependency>

     

    <!-- 配置dubbo启动器 -->

    <dependency>

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

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

    <version>1.4.4.RELEASE</version>

    <optional>true</optional>

    </dependency>

    </dependencies>

    </project>

     

    3.6.2.2. 搭建taotao-interface

    创建taotao-interface,并打jar包。

    修改pom.xml为如下,几乎不用配置

    <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>com.taotao</groupId>

    <artifactId>taotao-parent</artifactId>

    <version>0.0.1-SNAPSHOT</version>

    </parent>

    <groupId>com.taotao</groupId>

    <artifactId>taotao-interface</artifactId>

    <version>0.0.1-SNAPSHOT</version>

    </project>

     

    3.6.2.3. 搭建taotao-provider

    创建taotao-provider,并打jar包。

    修改pom.xml为如下

    <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>com.taotao</groupId>

    <artifactId>taotao-parent</artifactId>

    <version>0.0.1-SNAPSHOT</version>

    </parent>

    <groupId>com.taotao</groupId>

    <artifactId>taotao-provider</artifactId>

    <version>0.0.1-SNAPSHOT</version>

     

    <dependencies>

    <!-- 加入taotao-interface依赖 -->

    <dependency>

    <groupId>com.taotao</groupId>

    <artifactId>taotao-interface</artifactId>

    <version>0.0.1-SNAPSHOT</version>

    </dependency>

     

    <!-- 配置MyBatis启动器 -->

    <dependency>

    <groupId>org.mybatis.spring.boot</groupId>

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

    <version>1.1.1</version>

    </dependency>

     

    <!-- MySQL连接驱动 -->

    <dependency>

    <groupId>mysql</groupId>

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

    </dependency>

    </dependencies>

    </project>

     

    3.6.2.4. 搭建taotao-consumer

    创建taotao-consumer,并打jar包。

    修改pom.xml为如下

    <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>com.taotao</groupId>

    <artifactId>taotao-parent</artifactId>

    <version>0.0.1-SNAPSHOT</version>

    </parent>

    <groupId>com.taotao</groupId>

    <artifactId>taotao-consumer</artifactId>

    <version>0.0.1-SNAPSHOT</version>

     

    <dependencies>

    <!-- 加入taotao-interface依赖 -->

    <dependency>

    <groupId>com.taotao</groupId>

    <artifactId>taotao-interface</artifactId>

    <version>0.0.1-SNAPSHOT</version>

    </dependency>

    </dependencies>

    </project>

     

    3.7. 实现功能

    3.7.1. 实现taotao-interface

    编写pojo

    import java.io.Serializable;

     

    public class User implements Serializable {

    private Long id;

    private String userName;

    private String password;

    private String name;

    get/set方法

    }

     

    编写Service接口

    import com.taotao.common.pojo.User;

     

    public interface UserService {

     

    public User queryUserById(Long id);

    }

     

    3.7.2. 实现taotao-provider

    编写UserMapper

    import org.apache.ibatis.annotations.Mapper;

    import org.apache.ibatis.annotations.Select;

    import com.taotao.common.pojo.User;

     

    @Mapper

    public interface UserMapper {

     

    @Select("select * from user where id=#{id}")

    public User queryUserById(Long id);

     

    }

     

    编写UserServiceImpl实现类

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

    import com.alibaba.dubbo.config.annotation.Service;

    import com.taotao.common.consumer.UserService;

    import com.taotao.common.pojo.User;

    import com.taotao.mapper.UserMapper;

     

    @Service

    public class UserServiceImpl implements UserService {

     

    @Autowired

    private UserMapper userMapper;

     

    @Override

    public User queryUserById(Long id) {

    User user = this.userMapper.queryUserById(id);

    return user;

    }

    }

     

    编写引导类

    import org.springframework.boot.SpringApplication;

    import org.springframework.boot.autoconfigure.SpringBootApplication;

    import com.alibaba.boot.dubbo.EnableDubboAutoConfiguration;

     

    @SpringBootApplication

    @EnableDubboAutoConfiguration

    public class ProviderApplication {

    public static void main(String[] args) {

    SpringApplication.run(ProviderApplication.classargs);

    }

    }

     

    在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

     

    #配置服务器访问端口号

    server.port=8081

     

    #配置dubbo信息

    #配置服务名称

    spring.dubbo.application.name=taotao-provider

    #注册中心类型

    spring.dubbo.registry.protocol=zookeeper

    #注册中心连接方式

    spring.dubbo.registry.address=manager.taotao.com:2181

    #配置服务调用所使用的协议

    spring.dubbo.protocol.name=dubbo

    #配置服务端口号

    spring.dubbo.protocol.port=20880

    #配置服务访问地址

    spring.dubbo.protocol.host=localhost

    #配置dubbo扫描

    spring.dubbo.scan=com.taotao.provider

     

     

    3.7.3. 实现taotao-consumer

    编写Controller

    import org.springframework.web.bind.annotation.PathVariable;

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

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

    import com.alibaba.dubbo.config.annotation.Reference;

    import com.taotao.common.consumer.UserService;

    import com.taotao.common.pojo.User;

     

    @RestController

    @RequestMapping("user")

    public class UserController {

     

    @Reference

    private UserService userService;

     

    @RequestMapping("{id}")

    public User queryUserById(@PathVariable Long id) {

    User user = this.userService.queryUserById(id);

    return user;

    }

    }

     

    编写引导类

    import org.springframework.boot.SpringApplication;

    import org.springframework.boot.autoconfigure.SpringBootApplication;

    import com.alibaba.boot.dubbo.EnableDubboAutoConfiguration;

     

    @SpringBootApplication

    @EnableDubboAutoConfiguration

    public class ConsumerApplication {

    public static void main(String[] args) {

    SpringApplication.run(ConsumerApplication.classargs);

    }

    }

     

    在src/main/resources加入配置文件application.properties

    #配置服务器访问端口号

    server.port=8080

     

    #配置dubbo信息

    #配置服务名称

    spring.dubbo.application.name=taotao-consumer

    #注册中心类型

    spring.dubbo.registry.protocol=zookeeper

    #注册中心连接方式

    spring.dubbo.registry.address=manager.taotao.com:2181

    #配置服务调用所使用的协议

    spring.dubbo.protocol.name=dubbo

    #配置服务端口号

    spring.dubbo.protocol.port=20880

    #配置服务访问地址

    spring.dubbo.protocol.host=localhost

    #配置dubbo扫描

    spring.dubbo.scan=com.taotao.consumer

     

    4. Spring Boot深入学习

    4.1. 读取配置文件

    4.1.1. .读取核心配置文件

    在工程的src/main/resources 下修改核心配置文件

    application.properties, 添加内容如下

    name=传智播客

    url=http://www.cnn.cn

     

    在Controller中添加:

    @Resource

    private Environment env;

     

    @RequestMapping("list")

    public List<User> queryUserAll() {

    System.out.println(env.getProperty("name"));

    System.out.println(env.getProperty("url"));

    List<User> list = this.userService.findAll();

    return list;

    }

     

    就可以直接把配置文件信息打印出来。

    注意包名是:org.springframework.core.env.Environment

     

     

    4.1.2. 读取自定义文件

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

    mail.host=smtp.sina.com

    mail.port=25

    mail.username=cnn

    mail.password=heima

     

    编写JavaBean

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

    import org.springframework.context.annotation.Configuration;

     

    @Configuration

    @ConfigurationProperties(locations = "classpath:mail.properties", prefix = "mail")

    public class MailProperties {

    private String host;

    private Integer port;

    private String username; 

    private String password;

     

    set/get

    }

     

    改造Controller

    @Autowired

    private MailProperties mailProperties;

     

    @RequestMapping("/mailInfo")

    public String mailInfo() {

    return mailProperties.getHost() + "<br>" + mailProperties.getPort() + "<br>" + mailProperties.getUsername()

    "<br>" + mailProperties.getPassword();

    }

     

    打印效果

     

    4.2. 打jar包

    在工程的pom.xml中添加以下依赖

    <build>

    <plugins>

    <plugin>

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

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

    </plugin>

    </plugins>

    </build>

     

    我们目前的工程采用的是jar 的打包方式,所以我们在执行package 命令后,

    会产生一个jar 包。

    我们进入到这个目录用压缩软件打开此jar 包,其中我们发现了一个叫lib 的文件夹,打开lib 文件夹发现此文件夹下全是工程依赖的jar包,甚至还有tomcat。这种包含有jar 包的jar包,我们称之为fatJAR( 胖jar 包)

     

    由于fatJAR 本身就包括tomcat , 我们就不需要另外部署了,直接在命令行就可以把我们的应用启动起来,在命令行,进入到jar 包所在的目录,我们可以通过以下java –jar命令来执行此jar 包。

     

    在控制台会出现启动信息,在浏览器访问程序

     

    4.3. 打war包

    spring-boot 默认提供内嵌的tomcat,所以打包直接生成jar 包,用java

    -jar 命令就可以启动。但是,有时候我们更希望一个tomcat 来管理多个项目,

    这种情况下就需要项目是war 格式的包而不是jar 格式的包。

    我们按照以下步骤完成对工程的改造

    (1)修改pom.xml

    将打包方式修改为war

    <packaging>war</packaging>

     

    添加依赖

    <dependency>

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

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

    <scope>provided</scope>

    </dependency>

     

    spring-boot-starter-tomcat 是原来被传递过来的依赖,默认会打到包里,所

    以我们再次引入此依赖,并指定依赖范围为provided,这样tomcat 相关的jar

    就不会打包到war 里了.

     

    (2)添加ServletInitializer

    import org.springframework.boot.builder.SpringApplicationBuilder;

    import

    org.springframework.boot.context.web.SpringBootServletInitializer;

    public class ServletInitializer extends SpringBootServletInitializer {

    @Override

    protected SpringApplicationBuilder configure(SpringApplicationBuilder

    application) {

    return application.sources(Application.class);

    }

    }

    由于我们采用web3.0 规范,是没有web.xml 的,而此类的作用与web.xml

    相同。

    (3)运行package 打包命令生成war 包

    生成后将war 包放入tomcat,启动tomcat,测试完成的功能是否可以使用。

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

    附录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的替代方法

     

    附录2. Spring-boot的application.properties 

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

    # ===================================================================

    # COMMON SPRING BOOT PROPERTIES

    #

    # This sample file is provided as a guideline. Do NOT copy it in its

    # entirety to your own application.               ^^^

    # ===================================================================

     

     

    # ----------------------------------------

    # CORE PROPERTIES

    # ----------------------------------------

     

    # BANNER

    banner.charset=UTF-8 # Banner file encoding.

    banner.location=classpath:banner.txt # Banner file location.

    banner.image.location=classpath:banner.gif # Banner image file location (jpg/png can also be used).

    banner.image.width# Width of the banner image in chars (default 76)

    banner.image.height# Height of the banner image in chars (default based on image height)

    banner.image.margin# Left hand image margin in chars (default 2)

    banner.image.invert# If images should be inverted for dark terminal themes (default false)

     

    # LOGGING

    logging.config# Location of the logging configuration file. For instance `classpath:logback.xml` for Logback

    logging.exception-conversion-word=%wEx # Conversion word used when logging exceptions.

    logging.file# Log file name. For instance `myapp.log`

    logging.level.*# Log levels severity mapping. For instance `logging.level.org.springframework=DEBUG`

    logging.path# Location of the log file. For instance `/var/log`

    logging.pattern.console# Appender pattern for output to the console. Only supported with the default logback setup.

    logging.pattern.file# Appender pattern for output to the file. Only supported with the default logback setup.

    logging.pattern.level# Appender pattern for log level (default %5p). Only supported with the default logback setup.

    logging.register-shutdown-hook=false # Register a shutdown hook for the logging system when it is initialized.

     

    # AOP

    spring.aop.auto=true # Add @EnableAspectJAutoProxy.

    spring.aop.proxy-target-class=false # Whether subclass-based (CGLIB) proxies are to be created (true) as opposed to standard Java interface-based proxies (false).

     

    # IDENTITY (ContextIdApplicationContextInitializer)

    spring.application.index# Application index.

    spring.application.name# Application name.

     

    # ADMIN (SpringApplicationAdminJmxAutoConfiguration)

    spring.application.admin.enabled=false # Enable admin features for the application.

    spring.application.admin.jmx-name=org.springframework.boot:type=Admin,name=SpringApplication # JMX name of the application admin MBean.

     

    # AUTO-CONFIGURATION

    spring.autoconfigure.exclude# Auto-configuration classes to exclude.

     

    # SPRING CORE

    spring.beaninfo.ignore=true # Skip search of BeanInfo classes.

     

    # SPRING CACHE (CacheProperties)

    spring.cache.cache-names# Comma-separated list of cache names to create if supported by the underlying cache manager.

    spring.cache.caffeine.spec# The spec to use to create caches. Check CaffeineSpec for more details on the spec format.

    spring.cache.couchbase.expiration=0 # Entry expiration in milliseconds. By default the entries never expire.

    spring.cache.ehcache.config# The location of the configuration file to use to initialize EhCache.

    spring.cache.guava.spec# The spec to use to create caches. Check CacheBuilderSpec for more details on the spec format.

    spring.cache.hazelcast.config# The location of the configuration file to use to initialize Hazelcast.

    spring.cache.infinispan.config# The location of the configuration file to use to initialize Infinispan.

    spring.cache.jcache.config# The location of the configuration file to use to initialize the cache manager.

    spring.cache.jcache.provider# Fully qualified name of the CachingProvider implementation to use to retrieve the JSR-107 compliant cache manager. Only needed if more than one JSR-107 implementation is available on the classpath.

    spring.cache.type# Cache type, auto-detected according to the environment by default.

     

    # SPRING CONFIG - using environment property only (ConfigFileApplicationListener)

    spring.config.location# Config file locations.

    spring.config.name=application # Config file name.

     

    # HAZELCAST (HazelcastProperties)

    spring.hazelcast.config# The location of the configuration file to use to initialize Hazelcast.

     

    # PROJECT INFORMATION (ProjectInfoProperties)

    spring.info.build.location=classpath:META-INF/build-info.properties # Location of the generated build-info.properties file.

    spring.info.git.location=classpath:git.properties # Location of the generated git.properties file.

     

    # JMX

    spring.jmx.default-domain# JMX domain name.

    spring.jmx.enabled=true # Expose management beans to the JMX domain.

    spring.jmx.server=mbeanServer # MBeanServer bean name.

     

    # Email (MailProperties)

    spring.mail.default-encoding=UTF-8 # Default MimeMessage encoding.

    spring.mail.host# SMTP server host. For instance `smtp.example.com`

    spring.mail.jndi-name# Session JNDI name. When set, takes precedence to others mail settings.

    spring.mail.password# Login password of the SMTP server.

    spring.mail.port# SMTP server port.

    spring.mail.properties.*# Additional JavaMail session properties.

    spring.mail.protocol=smtp # Protocol used by the SMTP server.

    spring.mail.test-connection=false # Test that the mail server is available on startup.

    spring.mail.username# Login user of the SMTP server.

     

    # APPLICATION SETTINGS (SpringApplication)

    spring.main.banner-mode=console # Mode used to display the banner when the application runs.

    spring.main.sources# Sources (class name, package name or XML resource location) to include in the ApplicationContext.

    spring.main.web-environment# Run the application in a web environment (auto-detected by default).

     

    # FILE ENCODING (FileEncodingApplicationListener)

    spring.mandatory-file-encoding# Expected character encoding the application must use.

     

    # INTERNATIONALIZATION (MessageSourceAutoConfiguration)

    spring.messages.always-use-message-format=false # Set whether to always apply the MessageFormat rules, parsing even messages without arguments.

    spring.messages.basename=messages # Comma-separated list of basenames, each following the ResourceBundle convention.

    spring.messages.cache-seconds=-1 # Loaded resource bundle files cache expiration, in seconds. When set to -1, bundles are cached forever.

    spring.messages.encoding=UTF-8 # Message bundles encoding.

    spring.messages.fallback-to-system-locale=true # Set whether to fall back to the system Locale if no files for a specific Locale have been found.

     

    # OUTPUT

    spring.output.ansi.enabled=detect # Configure the ANSI output.

     

    # PID FILE (ApplicationPidFileWriter)

    spring.pid.fail-on-write-error# Fail if ApplicationPidFileWriter is used but it cannot write the PID file.

    spring.pid.file# Location of the PID file to write (if ApplicationPidFileWriter is used).

     

    # PROFILES

    spring.profiles.active# Comma-separated list of active profiles.

    spring.profiles.include# Unconditionally activate the specified comma separated profiles.

     

    # SENDGRID (SendGridAutoConfiguration)

    spring.sendgrid.api-key# SendGrid api key (alternative to username/password)

    spring.sendgrid.username# SendGrid account username

    spring.sendgrid.password# SendGrid account password

    spring.sendgrid.proxy.host# SendGrid proxy host

    spring.sendgrid.proxy.port# SendGrid proxy port

     

     

    # ----------------------------------------

    # WEB PROPERTIES

    # ----------------------------------------

     

    # EMBEDDED SERVER CONFIGURATION (ServerProperties)

    server.address# Network address to which the server should bind to.

    server.compression.enabled=false # If response compression is enabled.

    server.compression.excluded-user-agents# List of user-agents to exclude from compression.

    server.compression.mime-types# Comma-separated list of MIME types that should be compressed. For instance `text/html,text/css,application/json`

    server.compression.min-response-size# Minimum response size that is required for compression to be performed. For instance 2048

    server.connection-timeout# Time in milliseconds that connectors will wait for another HTTP request before closing the connection. When not set, the connector's container-specific default will be used. Use a value of -1 to indicate no (i.e. infinite) timeout.

    server.context-parameters.*# Servlet context init parameters. For instance `server.context-parameters.a=alpha`

    server.context-path# Context path of the application.

    server.display-name=application # Display name of the application.

    server.max-http-header-size=0 # Maximum size in bytes of the HTTP message header.

    server.max-http-post-size=0 # Maximum size in bytes of the HTTP post content.

    server.error.include-stacktrace=never # When to include a "stacktrace" attribute.

    server.error.path=/error # Path of the error controller.

    server.error.whitelabel.enabled=true # Enable the default error page displayed in browsers in case of a server error.

    server.jetty.acceptors# Number of acceptor threads to use.

    server.jetty.selectors# Number of selector threads to use.

    server.jsp-servlet.class-name=org.apache.jasper.servlet.JspServlet # The class name of the JSP servlet.

    server.jsp-servlet.init-parameters.*# Init parameters used to configure the JSP servlet

    server.jsp-servlet.registered=true # Whether or not the JSP servlet is registered

    server.port=8080 # Server HTTP port.

    server.server-header# Value to use for the Server response header (no header is sent if empty)

    server.servlet-path=/ # Path of the main dispatcher servlet.

    server.use-forward-headers# If X-Forwarded-* headers should be applied to the HttpRequest.

    server.session.cookie.comment# Comment for the session cookie.

    server.session.cookie.domain# Domain for the session cookie.

    server.session.cookie.http-only# "HttpOnly" flag for the session cookie.

    server.session.cookie.max-age# Maximum age of the session cookie in seconds.

    server.session.cookie.name# Session cookie name.

    server.session.cookie.path# Path of the session cookie.

    server.session.cookie.secure# "Secure" flag for the session cookie.

    server.session.persistent=false # Persist session data between restarts.

    server.session.store-dir# Directory used to store session data.

    server.session.timeout# Session timeout in seconds.

    server.session.tracking-modes# Session tracking modes (one or more of the following: "cookie", "url", "ssl").

    server.ssl.ciphers# Supported SSL ciphers.

    server.ssl.client-auth# Whether client authentication is wanted ("want") or needed ("need"). Requires a trust store.

    server.ssl.enabled# Enable SSL support.

    server.ssl.enabled-protocols# Enabled SSL protocols.

    server.ssl.key-alias# Alias that identifies the key in the key store.

    server.ssl.key-password# Password used to access the key in the key store.

    server.ssl.key-store# Path to the key store that holds the SSL certificate (typically a jks file).

    server.ssl.key-store-password# Password used to access the key store.

    server.ssl.key-store-provider# Provider for the key store.

    server.ssl.key-store-type# Type of the key store.

    server.ssl.protocol=TLS # SSL protocol to use.

    server.ssl.trust-store# Trust store that holds SSL certificates.

    server.ssl.trust-store-password# Password used to access the trust store.

    server.ssl.trust-store-provider# Provider for the trust store.

    server.ssl.trust-store-type# Type of the trust store.

    server.tomcat.accesslog.directory=logs # Directory in which log files are created. Can be relative to the tomcat base dir or absolute.

    server.tomcat.accesslog.enabled=false # Enable access log.

    server.tomcat.accesslog.pattern=common # Format pattern for access logs.

    server.tomcat.accesslog.prefix=access_log # Log file name prefix.

    server.tomcat.accesslog.rename-on-rotate=false # Defer inclusion of the date stamp in the file name until rotate time.

    server.tomcat.accesslog.request-attributes-enabled=false # Set request attributes for IP address, Hostname, protocol and port used for the request.

    server.tomcat.accesslog.suffix=.log # Log file name suffix.

    server.tomcat.background-processor-delay=30 # Delay in seconds between the invocation of backgroundProcess methods.

    server.tomcat.basedir# Tomcat base directory. If not specified a temporary directory will be used.

    server.tomcat.internal-proxies=10\\.\\d{1,3}\\.\\d{1,3}\\.\\d{1,3}|\\

            192\\.168\\.\\d{1,3}\\.\\d{1,3}|\\

            169\\.254\\.\\d{1,3}\\.\\d{1,3}|\\

            127\\.\\d{1,3}\\.\\d{1,3}\\.\\d{1,3}|\\

            172\\.1[6-9]{1}\\.\\d{1,3}\\.\\d{1,3}|\\

            172\\.2[0-9]{1}\\.\\d{1,3}\\.\\d{1,3}|\\

            172\\.3[0-1]{1}\\.\\d{1,3}\\.\\d{1,3} # regular expression matching trusted IP addresses.

    server.tomcat.max-threads=0 # Maximum amount of worker threads.

    server.tomcat.min-spare-threads=0 # Minimum amount of worker threads.

    server.tomcat.port-header=X-Forwarded-Port # Name of the HTTP header used to override the original port value.

    server.tomcat.protocol-header# Header that holds the incoming protocol, usually named "X-Forwarded-Proto".

    server.tomcat.protocol-header-https-value=https # Value of the protocol header that indicates that the incoming request uses SSL.

    server.tomcat.redirect-context-root# Whether requests to the context root should be redirected by appending a / to the path.

    server.tomcat.remote-ip-header# Name of the http header from which the remote ip is extracted. For instance `X-FORWARDED-FOR`

    server.tomcat.uri-encoding=UTF-8 # Character encoding to use to decode the URI.

    server.undertow.accesslog.dir# Undertow access log directory.

    server.undertow.accesslog.enabled=false # Enable access log.

    server.undertow.accesslog.pattern=common # Format pattern for access logs.

    server.undertow.accesslog.prefix=access_log. # Log file name prefix.

    server.undertow.accesslog.suffix=log # Log file name suffix.

    server.undertow.buffer-size# Size of each buffer in bytes.

    server.undertow.buffers-per-region# Number of buffer per region.

    server.undertow.direct-buffers# Allocate buffers outside the Java heap.

    server.undertow.io-threads# Number of I/O threads to create for the worker.

    server.undertow.worker-threads# Number of worker threads.

     

    # FREEMARKER (FreeMarkerAutoConfiguration)

    spring.freemarker.allow-request-override=false # Set whether HttpServletRequest attributes are allowed to override (hide) controller generated model attributes of the same name.

    spring.freemarker.allow-session-override=false # Set whether HttpSession attributes are allowed to override (hide) controller generated model attributes of the same name.

    spring.freemarker.cache=false # Enable template caching.

    spring.freemarker.charset=UTF-8 # Template encoding.

    spring.freemarker.check-template-location=true # Check that the templates location exists.

    spring.freemarker.content-type=text/html # Content-Type value.

    spring.freemarker.enabled=true # Enable MVC view resolution for this technology.

    spring.freemarker.expose-request-attributes=false # Set whether all request attributes should be added to the model prior to merging with the template.

    spring.freemarker.expose-session-attributes=false # Set whether all HttpSession attributes should be added to the model prior to merging with the template.

    spring.freemarker.expose-spring-macro-helpers=true # Set whether to expose a RequestContext for use by Spring's macro library, under the name "springMacroRequestContext".

    spring.freemarker.prefer-file-system-access=true # Prefer file system access for template loading. File system access enables hot detection of template changes.

    spring.freemarker.prefix# Prefix that gets prepended to view names when building a URL.

    spring.freemarker.request-context-attribute# Name of the RequestContext attribute for all views.

    spring.freemarker.settings.*# Well-known FreeMarker keys which will be passed to FreeMarker's Configuration.

    spring.freemarker.suffix# Suffix that gets appended to view names when building a URL.

    spring.freemarker.template-loader-path=classpath:/templates/ # Comma-separated list of template paths.

    spring.freemarker.view-names# White list of view names that can be resolved.

     

    # GROOVY TEMPLATES (GroovyTemplateAutoConfiguration)

    spring.groovy.template.allow-request-override=false # Set whether HttpServletRequest attributes are allowed to override (hide) controller generated model attributes of the same name.

    spring.groovy.template.allow-session-override=false # Set whether HttpSession attributes are allowed to override (hide) controller generated model attributes of the same name.

    spring.groovy.template.cache# Enable template caching.

    spring.groovy.template.charset=UTF-8 # Template encoding.

    spring.groovy.template.check-template-location=true # Check that the templates location exists.

    spring.groovy.template.configuration.*# See GroovyMarkupConfigurer

    spring.groovy.template.content-type=test/html # Content-Type value.

    spring.groovy.template.enabled=true # Enable MVC view resolution for this technology.

    spring.groovy.template.expose-request-attributes=false # Set whether all request attributes should be added to the model prior to merging with the template.

    spring.groovy.template.expose-session-attributes=false # Set whether all HttpSession attributes should be added to the model prior to merging with the template.

    spring.groovy.template.expose-spring-macro-helpers=true # Set whether to expose a RequestContext for use by Spring's macro library, under the name "springMacroRequestContext".

    spring.groovy.template.prefix# Prefix that gets prepended to view names when building a URL.

    spring.groovy.template.request-context-attribute# Name of the RequestContext attribute for all views.

    spring.groovy.template.resource-loader-path=classpath:/templates/ # Template path.

    spring.groovy.template.suffix=.tpl # Suffix that gets appended to view names when building a URL.

    spring.groovy.template.view-names# White list of view names that can be resolved.

     

    # SPRING HATEOAS (HateoasProperties)

    spring.hateoas.use-hal-as-default-json-media-type=true # Specify if application/hal+json responses should be sent to requests that accept application/json.

     

    # HTTP message conversion

    spring.http.converters.preferred-json-mapper=jackson # Preferred JSON mapper to use for HTTP message conversion. Set to "gson" to force the use of Gson when both it and Jackson are on the classpath.

     

    # HTTP encoding (HttpEncodingProperties)

    spring.http.encoding.charset=UTF-8 # Charset of HTTP requests and responses. Added to the "Content-Type" header if not set explicitly.

    spring.http.encoding.enabled=true # Enable http encoding support.

    spring.http.encoding.force# Force the encoding to the configured charset on HTTP requests and responses.

    spring.http.encoding.force-request# Force the encoding to the configured charset on HTTP requests. Defaults to true when "force" has not been specified.

    spring.http.encoding.force-response# Force the encoding to the configured charset on HTTP responses.

    spring.http.encoding.mapping# Locale to Encoding mapping.

     

    # MULTIPART (MultipartProperties)

    spring.http.multipart.enabled=true # Enable support of multi-part uploads.

    spring.http.multipart.file-size-threshold=0 # Threshold after which files will be written to disk. Values can use the suffixed "MB" or "KB" to indicate a Megabyte or Kilobyte size.

    spring.http.multipart.location# Intermediate location of uploaded files.

    spring.http.multipart.max-file-size=1Mb # Max file size. Values can use the suffixed "MB" or "KB" to indicate a Megabyte or Kilobyte size.

    spring.http.multipart.max-request-size=10Mb # Max request size. Values can use the suffixed "MB" or "KB" to indicate a Megabyte or Kilobyte size.

    spring.http.multipart.resolve-lazily=false # Whether to resolve the multipart request lazily at the time of file or parameter access.

     

    # JACKSON (JacksonProperties)

    spring.jackson.date-format# Date format string or a fully-qualified date format class name. For instance `yyyy-MM-dd HH:mm:ss`.

    spring.jackson.default-property-inclusion# Controls the inclusion of properties during serialization.

    spring.jackson.deserialization.*# Jackson on/off features that affect the way Java objects are deserialized.

    spring.jackson.generator.*# Jackson on/off features for generators.

    spring.jackson.joda-date-time-format# Joda date time format string. If not configured, "date-format" will be used as a fallback if it is configured with a format string.

    spring.jackson.locale# Locale used for formatting.

    spring.jackson.mapper.*# Jackson general purpose on/off features.

    spring.jackson.parser.*# Jackson on/off features for parsers.

    spring.jackson.property-naming-strategy# One of the constants on Jackson's PropertyNamingStrategy. Can also be a fully-qualified class name of a PropertyNamingStrategy subclass.

    spring.jackson.serialization.*# Jackson on/off features that affect the way Java objects are serialized.

    spring.jackson.serialization-inclusion# Controls the inclusion of properties during serialization. Configured with one of the values in Jackson's JsonInclude.Include enumeration.

    spring.jackson.time-zone# Time zone used when formatting dates. For instance `America/Los_Angeles`

     

    # JERSEY (JerseyProperties)

    spring.jersey.application-path# Path that serves as the base URI for the application. Overrides the value of "@ApplicationPath" if specified.

    spring.jersey.filter.order=0 # Jersey filter chain order.

    spring.jersey.init.*# Init parameters to pass to Jersey via the servlet or filter.

    spring.jersey.servlet.load-on-startup=-1 # Load on startup priority of the Jersey servlet.

    spring.jersey.type=servlet # Jersey integration type.

     

    # SPRING MOBILE DEVICE VIEWS (DeviceDelegatingViewResolverAutoConfiguration)

    spring.mobile.devicedelegatingviewresolver.enable-fallback=false # Enable support for fallback resolution.

    spring.mobile.devicedelegatingviewresolver.enabled=false # Enable device view resolver.

    spring.mobile.devicedelegatingviewresolver.mobile-prefix=mobile/ # Prefix that gets prepended to view names for mobile devices.

    spring.mobile.devicedelegatingviewresolver.mobile-suffix# Suffix that gets appended to view names for mobile devices.

    spring.mobile.devicedelegatingviewresolver.normal-prefix# Prefix that gets prepended to view names for normal devices.

    spring.mobile.devicedelegatingviewresolver.normal-suffix# Suffix that gets appended to view names for normal devices.

    spring.mobile.devicedelegatingviewresolver.tablet-prefix=tablet/ # Prefix that gets prepended to view names for tablet devices.

    spring.mobile.devicedelegatingviewresolver.tablet-suffix# Suffix that gets appended to view names for tablet devices.

     

    # SPRING MOBILE SITE PREFERENCE (SitePreferenceAutoConfiguration)

    spring.mobile.sitepreference.enabled=true # Enable SitePreferenceHandler.

     

    # MUSTACHE TEMPLATES (MustacheAutoConfiguration)

    spring.mustache.allow-request-override# Set whether HttpServletRequest attributes are allowed to override (hide) controller generated model attributes of the same name.

    spring.mustache.allow-session-override# Set whether HttpSession attributes are allowed to override (hide) controller generated model attributes of the same name.

    spring.mustache.cache# Enable template caching.

    spring.mustache.charset# Template encoding.

    spring.mustache.check-template-location# Check that the templates location exists.

    spring.mustache.content-type# Content-Type value.

    spring.mustache.enabled# Enable MVC view resolution for this technology.

    spring.mustache.expose-request-attributes# Set whether all request attributes should be added to the model prior to merging with the template.

    spring.mustache.expose-session-attributes# Set whether all HttpSession attributes should be added to the model prior to merging with the template.

    spring.mustache.expose-spring-macro-helpers# Set whether to expose a RequestContext for use by Spring's macro library, under the name "springMacroRequestContext".

    spring.mustache.prefix=classpath:/templates/ # Prefix to apply to template names.

    spring.mustache.request-context-attribute# Name of the RequestContext attribute for all views.

    spring.mustache.suffix=.html # Suffix to apply to template names.

    spring.mustache.view-names# White list of view names that can be resolved.

     

    # SPRING MVC (WebMvcProperties)

    spring.mvc.async.request-timeout# Amount of time (in milliseconds) before asynchronous request handling times out.

    spring.mvc.date-format# Date format to use. For instance `dd/MM/yyyy`.

    spring.mvc.dispatch-trace-request=false # Dispatch TRACE requests to the FrameworkServlet doService method.

    spring.mvc.dispatch-options-request=true # Dispatch OPTIONS requests to the FrameworkServlet doService method.

    spring.mvc.favicon.enabled=true # Enable resolution of favicon.ico.

    spring.mvc.formcontent.putfilter.enabled=true # Enable Spring's HttpPutFormContentFilter.

    spring.mvc.ignore-default-model-on-redirect=true # If the content of the "default" model should be ignored during redirect scenarios.

    spring.mvc.locale# Locale to use. By default, this locale is overridden by the "Accept-Language" header.

    spring.mvc.locale-resolver=accept-header # Define how the locale should be resolved.

    spring.mvc.log-resolved-exception=false # Enable warn logging of exceptions resolved by a "HandlerExceptionResolver".

    spring.mvc.media-types.*# Maps file extensions to media types for content negotiation.

    spring.mvc.message-codes-resolver-format# Formatting strategy for message codes. For instance `PREFIX_ERROR_CODE`.

    spring.mvc.servlet.load-on-startup=-1 # Load on startup priority of the Spring Web Services servlet.

    spring.mvc.static-path-pattern=/** # Path pattern used for static resources.

    spring.mvc.throw-exception-if-no-handler-found=false # If a "NoHandlerFoundException" should be thrown if no Handler was found to process a request.

    spring.mvc.view.prefix# Spring MVC view prefix.

    spring.mvc.view.suffix# Spring MVC view suffix.

     

    # SPRING RESOURCES HANDLING (ResourceProperties)

    spring.resources.add-mappings=true # Enable default resource handling.

    spring.resources.cache-period# Cache period for the resources served by the resource handler, in seconds.

    spring.resources.chain.cache=true # Enable caching in the Resource chain.

    spring.resources.chain.enabled# Enable the Spring Resource Handling chain. Disabled by default unless at least one strategy has been enabled.

    spring.resources.chain.gzipped=false # Enable resolution of already gzipped resources.

    spring.resources.chain.html-application-cache=false # Enable HTML5 application cache manifest rewriting.

    spring.resources.chain.strategy.content.enabled=false # Enable the content Version Strategy.

    spring.resources.chain.strategy.content.paths=/** # Comma-separated list of patterns to apply to the Version Strategy.

    spring.resources.chain.strategy.fixed.enabled=false # Enable the fixed Version Strategy.

    spring.resources.chain.strategy.fixed.paths=/** # Comma-separated list of patterns to apply to the Version Strategy.

    spring.resources.chain.strategy.fixed.version# Version string to use for the Version Strategy.

    spring.resources.static-locations=classpath:/META-INF/resources/,classpath:/resources/,classpath:/static/,classpath:/public/ # Locations of static resources.

     

    # SPRING SESSION (SessionProperties)

    spring.session.hazelcast.map-name=spring:session:sessions # Name of the map used to store sessions.

    spring.session.jdbc.initializer.enabled# Create the required session tables on startup if necessary. Enabled automatically if the default table name is set or a custom schema is configured.

    spring.session.jdbc.schema=classpath:org/springframework/session/jdbc/schema-@@platform@@.sql # Path to the SQL file to use to initialize the database schema.

    spring.session.jdbc.table-name=SPRING_SESSION # Name of database table used to store sessions.

    spring.session.mongo.collection-name=sessions # Collection name used to store sessions.

    spring.session.redis.flush-mode# Flush mode for the Redis sessions.

    spring.session.redis.namespace# Namespace for keys used to store sessions.

    spring.session.store-type# Session store type.

     

    # SPRING SOCIAL (SocialWebAutoConfiguration)

    spring.social.auto-connection-views=false # Enable the connection status view for supported providers.

     

    # SPRING SOCIAL FACEBOOK (FacebookAutoConfiguration)

    spring.social.facebook.app-id# your application's Facebook App ID

    spring.social.facebook.app-secret# your application's Facebook App Secret

     

    # SPRING SOCIAL LINKEDIN (LinkedInAutoConfiguration)

    spring.social.linkedin.app-id# your application's LinkedIn App ID

    spring.social.linkedin.app-secret# your application's LinkedIn App Secret

     

    # SPRING SOCIAL TWITTER (TwitterAutoConfiguration)

    spring.social.twitter.app-id# your application's Twitter App ID

    spring.social.twitter.app-secret# your application's Twitter App Secret

     

    # THYMELEAF (ThymeleafAutoConfiguration)

    spring.thymeleaf.cache=true # Enable template caching.

    spring.thymeleaf.check-template=true # Check that the template exists before rendering it.

    spring.thymeleaf.check-template-location=true # Check that the templates location exists.

    spring.thymeleaf.content-type=text/html # Content-Type value.

    spring.thymeleaf.enabled=true # Enable MVC Thymeleaf view resolution.

    spring.thymeleaf.encoding=UTF-8 # Template encoding.

    spring.thymeleaf.excluded-view-names# Comma-separated list of view names that should be excluded from resolution.

    spring.thymeleaf.mode=HTML5 # Template mode to be applied to templates. See also StandardTemplateModeHandlers.

    spring.thymeleaf.prefix=classpath:/templates/ # Prefix that gets prepended to view names when building a URL.

    spring.thymeleaf.suffix=.html # Suffix that gets appended to view names when building a URL.

    spring.thymeleaf.template-resolver-order# Order of the template resolver in the chain.

    spring.thymeleaf.view-names# Comma-separated list of view names that can be resolved.

     

    # VELOCITY TEMPLATES (VelocityAutoConfiguration)

    spring.velocity.allow-request-override=false # Set whether HttpServletRequest attributes are allowed to override (hide) controller generated model attributes of the same name.

    spring.velocity.allow-session-override=false # Set whether HttpSession attributes are allowed to override (hide) controller generated model attributes of the same name.

    spring.velocity.cache# Enable template caching.

    spring.velocity.charset=UTF-8 # Template encoding.

    spring.velocity.check-template-location=true # Check that the templates location exists.

    spring.velocity.content-type=text/html # Content-Type value.

    spring.velocity.date-tool-attribute# Name of the DateTool helper object to expose in the Velocity context of the view.

    spring.velocity.enabled=true # Enable MVC view resolution for this technology.

    spring.velocity.expose-request-attributes=false # Set whether all request attributes should be added to the model prior to merging with the template.

    spring.velocity.expose-session-attributes=false # Set whether all HttpSession attributes should be added to the model prior to merging with the template.

    spring.velocity.expose-spring-macro-helpers=true # Set whether to expose a RequestContext for use by Spring's macro library, under the name "springMacroRequestContext".

    spring.velocity.number-tool-attribute# Name of the NumberTool helper object to expose in the Velocity context of the view.

    spring.velocity.prefer-file-system-access=true # Prefer file system access for template loading. File system access enables hot detection of template changes.

    spring.velocity.prefix# Prefix that gets prepended to view names when building a URL.

    spring.velocity.properties.*# Additional velocity properties.

    spring.velocity.request-context-attribute# Name of the RequestContext attribute for all views.

    spring.velocity.resource-loader-path=classpath:/templates/ # Template path.

    spring.velocity.suffix=.vm # Suffix that gets appended to view names when building a URL.

    spring.velocity.toolbox-config-location# Velocity Toolbox config location. For instance `/WEB-INF/toolbox.xml`

    spring.velocity.view-names# White list of view names that can be resolved.

     

    # SPRING WEB SERVICES (WebServicesProperties)

    spring.webservices.path=/services # Path that serves as the base URI for the services.

    spring.webservices.servlet.init# Servlet init parameters to pass to Spring Web Services.

    spring.webservices.servlet.load-on-startup=-1 # Load on startup priority of the Spring Web Services servlet.

     

     

     

    # ----------------------------------------

    # SECURITY PROPERTIES

    # ----------------------------------------

    # SECURITY (SecurityProperties)

    security.basic.authorize-mode=role # Security authorize mode to apply.

    security.basic.enabled=true # Enable basic authentication.

    security.basic.path=/** # Comma-separated list of paths to secure.

    security.basic.realm=Spring # HTTP basic realm name.

    security.enable-csrf=false # Enable Cross Site Request Forgery support.

    security.filter-order=0 # Security filter chain order.

    security.filter-dispatcher-types=ASYNC, FORWARD, INCLUDE, REQUEST # Security filter chain dispatcher types.

    security.headers.cache=true # Enable cache control HTTP headers.

    security.headers.content-type=true # Enable "X-Content-Type-Options" header.

    security.headers.frame=true # Enable "X-Frame-Options" header.

    security.headers.hsts# HTTP Strict Transport Security (HSTS) mode (none, domain, all).

    security.headers.xss=true # Enable cross site scripting (XSS) protection.

    security.ignored# Comma-separated list of paths to exclude from the default secured paths.

    security.require-ssl=false # Enable secure channel for all requests.

    security.sessions=stateless # Session creation policy (always, never, if_required, stateless).

    security.user.name=user # Default user name.

    security.user.password# Password for the default user name. A random password is logged on startup by default.

    security.user.role=USER # Granted roles for the default user name.

     

    # SECURITY OAUTH2 CLIENT (OAuth2ClientProperties)

    security.oauth2.client.client-id# OAuth2 client id.

    security.oauth2.client.client-secret# OAuth2 client secret. A random secret is generated by default

     

    # SECURITY OAUTH2 RESOURCES (ResourceServerProperties)

    security.oauth2.resource.id# Identifier of the resource.

    security.oauth2.resource.jwt.key-uri# The URI of the JWT token. Can be set if the value is not available and the key is public.

    security.oauth2.resource.jwt.key-value# The verification key of the JWT token. Can either be a symmetric secret or PEM-encoded RSA public key.

    security.oauth2.resource.prefer-token-info=true # Use the token info, can be set to false to use the user info.

    security.oauth2.resource.service-id=resource #

    security.oauth2.resource.token-info-uri# URI of the token decoding endpoint.

    security.oauth2.resource.token-type# The token type to send when using the userInfoUri.

    security.oauth2.resource.user-info-uri# URI of the user endpoint.

     

    # SECURITY OAUTH2 SSO (OAuth2SsoProperties)

    security.oauth2.sso.filter-order# Filter order to apply if not providing an explicit WebSecurityConfigurerAdapter

    security.oauth2.sso.login-path=/login # Path to the login page, i.e. the one that triggers the redirect to the OAuth2 Authorization Server

     

     

    # ----------------------------------------

    # DATA PROPERTIES

    # ----------------------------------------

     

    # FLYWAY (FlywayProperties)

    flyway.baseline-description#

    flyway.baseline-version=1 # version to start migration

    flyway.baseline-on-migrate#

    flyway.check-location=false # Check that migration scripts location exists.

    flyway.clean-on-validation-error#

    flyway.enabled=true # Enable flyway.

    flyway.encoding#

    flyway.ignore-failed-future-migration#

    flyway.init-sqls# SQL statements to execute to initialize a connection immediately after obtaining it.

    flyway.locations=classpath:db/migration # locations of migrations scripts

    flyway.out-of-order#

    flyway.password# JDBC password if you want Flyway to create its own DataSource

    flyway.placeholder-prefix#

    flyway.placeholder-replacement#

    flyway.placeholder-suffix#

    flyway.placeholders.*#

    flyway.schemas# schemas to update

    flyway.sql-migration-prefix=V #

    flyway.sql-migration-separator#

    flyway.sql-migration-suffix=.sql #

    flyway.table#

    flyway.url# JDBC url of the database to migrate. If not set, the primary configured data source is used.

    flyway.user# Login user of the database to migrate.

    flyway.validate-on-migrate#

     

    # LIQUIBASE (LiquibaseProperties)

    liquibase.change-log=classpath:/db/changelog/db.changelog-master.yaml # Change log configuration path.

    liquibase.check-change-log-location=true # Check the change log location exists.

    liquibase.contexts# Comma-separated list of runtime contexts to use.

    liquibase.default-schema# Default database schema.

    liquibase.drop-first=false # Drop the database schema first.

    liquibase.enabled=true # Enable liquibase support.

    liquibase.labels# Comma-separated list of runtime labels to use.

    liquibase.parameters.*# Change log parameters.

    liquibase.password# Login password of the database to migrate.

    liquibase.rollback-file# File to which rollback SQL will be written when an update is performed.

    liquibase.url# JDBC url of the database to migrate. If not set, the primary configured data source is used.

    liquibase.user# Login user of the database to migrate.

     

    # COUCHBASE (CouchbaseProperties)

    spring.couchbase.bootstrap-hosts# Couchbase nodes (host or IP address) to bootstrap from.

    spring.couchbase.bucket.name=default # Name of the bucket to connect to.

    spring.couchbase.bucket.password=  # Password of the bucket.

    spring.couchbase.env.endpoints.key-value=1 # Number of sockets per node against the Key/value service.

    spring.couchbase.env.endpoints.query=1 # Number of sockets per node against the Query (N1QL) service.

    spring.couchbase.env.endpoints.view=1 # Number of sockets per node against the view service.

    spring.couchbase.env.ssl.enabled# Enable SSL support. Enabled automatically if a "keyStore" is provided unless specified otherwise.

    spring.couchbase.env.ssl.key-store# Path to the JVM key store that holds the certificates.

    spring.couchbase.env.ssl.key-store-password# Password used to access the key store.

    spring.couchbase.env.timeouts.connect=5000 # Bucket connections timeout in milliseconds.

    spring.couchbase.env.timeouts.key-value=2500 # Blocking operations performed on a specific key timeout in milliseconds.

    spring.couchbase.env.timeouts.query=7500 # N1QL query operations timeout in milliseconds.

    spring.couchbase.env.timeouts.socket-connect=1000 # Socket connect connections timeout in milliseconds.

    spring.couchbase.env.timeouts.view=7500 # Regular and geospatial view operations timeout in milliseconds.

     

    # DAO (PersistenceExceptionTranslationAutoConfiguration)

    spring.dao.exceptiontranslation.enabled=true # Enable the PersistenceExceptionTranslationPostProcessor.

     

    # CASSANDRA (CassandraProperties)

    spring.data.cassandra.cluster-name# Name of the Cassandra cluster.

    spring.data.cassandra.compression# Compression supported by the Cassandra binary protocol.

    spring.data.cassandra.connect-timeout-millis# Socket option: connection time out.

    spring.data.cassandra.consistency-level# Queries consistency level.

    spring.data.cassandra.contact-points=localhost # Comma-separated list of cluster node addresses.

    spring.data.cassandra.fetch-size# Queries default fetch size.

    spring.data.cassandra.keyspace-name# Keyspace name to use.

    spring.data.cassandra.load-balancing-policy# Class name of the load balancing policy.

    spring.data.cassandra.port# Port of the Cassandra server.

    spring.data.cassandra.password# Login password of the server.

    spring.data.cassandra.read-timeout-millis# Socket option: read time out.

    spring.data.cassandra.reconnection-policy# Reconnection policy class.

    spring.data.cassandra.retry-policy# Class name of the retry policy.

    spring.data.cassandra.serial-consistency-level# Queries serial consistency level.

    spring.data.cassandra.schema-action=none # Schema action to take at startup.

    spring.data.cassandra.ssl=false # Enable SSL support.

    spring.data.cassandra.username# Login user of the server.

     

    # DATA COUCHBASE (CouchbaseDataProperties)

    spring.data.couchbase.auto-index=false # Automatically create views and indexes.

    spring.data.couchbase.consistency=read-your-own-writes # Consistency to apply by default on generated queries.

    spring.data.couchbase.repositories.enabled=true # Enable Couchbase repositories.

     

    # ELASTICSEARCH (ElasticsearchProperties)

    spring.data.elasticsearch.cluster-name=elasticsearch # Elasticsearch cluster name.

    spring.data.elasticsearch.cluster-nodes# Comma-separated list of cluster node addresses. If not specified, starts a client node.

    spring.data.elasticsearch.properties.*# Additional properties used to configure the client.

    spring.data.elasticsearch.repositories.enabled=true # Enable Elasticsearch repositories.

     

    # MONGODB (MongoProperties)

    spring.data.mongodb.authentication-database# Authentication database name.

    spring.data.mongodb.database=test # Database name.

    spring.data.mongodb.field-naming-strategy# Fully qualified name of the FieldNamingStrategy to use.

    spring.data.mongodb.grid-fs-database# GridFS database name.

    spring.data.mongodb.host=localhost # Mongo server host.

    spring.data.mongodb.password# Login password of the mongo server.

    spring.data.mongodb.port=27017 # Mongo server port.

    spring.data.mongodb.repositories.enabled=true # Enable Mongo repositories.

    spring.data.mongodb.uri=mongodb://localhost/test # Mongo database URI. When set, host and port are ignored.

    spring.data.mongodb.username# Login user of the mongo server.

     

    # DATA REDIS

    spring.data.redis.repositories.enabled=true # Enable Redis repositories.

     

    # NEO4J (Neo4jProperties)

    spring.data.neo4j.compiler# Compiler to use.

    spring.data.neo4j.embedded.enabled=true # Enable embedded mode if the embedded driver is available.

    spring.data.neo4j.password# Login password of the server.

    spring.data.neo4j.repositories.enabled=true # Enable Neo4j repositories.

    spring.data.neo4j.session.scope=singleton # Scope (lifetime) of the session.

    spring.data.neo4j.uri# URI used by the driver. Auto-detected by default.

    spring.data.neo4j.username# Login user of the server.

     

    # DATA REST (RepositoryRestProperties)

    spring.data.rest.base-path# Base path to be used by Spring Data REST to expose repository resources.

    spring.data.rest.default-page-size# Default size of pages.

    spring.data.rest.enable-enum-translation# Enable enum value translation via the Spring Data REST default resource bundle.

    spring.data.rest.limit-param-name# Name of the URL query string parameter that indicates how many results to return at once.

    spring.data.rest.max-page-size# Maximum size of pages.

    spring.data.rest.page-param-name# Name of the URL query string parameter that indicates what page to return.

    spring.data.rest.return-body-on-create# Return a response body after creating an entity.

    spring.data.rest.return-body-on-update# Return a response body after updating an entity.

    spring.data.rest.sort-param-name# Name of the URL query string parameter that indicates what direction to sort results.

     

    # SOLR (SolrProperties)

    spring.data.solr.host=http://127.0.0.1:8983/solr # Solr host. Ignored if "zk-host" is set.

    spring.data.solr.repositories.enabled=true # Enable Solr repositories.

    spring.data.solr.zk-host# ZooKeeper host address in the form HOST:PORT.

     

    # DATASOURCE (DataSourceAutoConfiguration & DataSourceProperties)

    spring.datasource.continue-on-error=false # Do not stop if an error occurs while initializing the database.

    spring.datasource.data# Data (DML) script resource reference.

    spring.datasource.data-username# User of the database to execute DML scripts (if different).

    spring.datasource.data-password# Password of the database to execute DML scripts (if different).

    spring.datasource.dbcp.*# Commons DBCP specific settings

    spring.datasource.dbcp2.*# Commons DBCP2 specific settings

    spring.datasource.driver-class-name# Fully qualified name of the JDBC driver. Auto-detected based on the URL by default.

    spring.datasource.generate-unique-name=false # Generate a random datasource name.

    spring.datasource.hikari.*# Hikari specific settings

    spring.datasource.initialize=true # Populate the database using 'data.sql'.

    spring.datasource.jmx-enabled=false # Enable JMX support (if provided by the underlying pool).

    spring.datasource.jndi-name# JNDI location of the datasource. Class, url, username & password are ignored when set.

    spring.datasource.name=testdb # Name of the datasource.

    spring.datasource.password# Login password of the database.

    spring.datasource.platform=all # Platform to use in the schema resource (schema-${platform}.sql).

    spring.datasource.schema# Schema (DDL) script resource reference.

    spring.datasource.schema-username# User of the database to execute DDL scripts (if different).

    spring.datasource.schema-password# Password of the database to execute DDL scripts (if different).

    spring.datasource.separator=; # Statement separator in SQL initialization scripts.

    spring.datasource.sql-script-encoding# SQL scripts encoding.

    spring.datasource.tomcat.*# Tomcat datasource specific settings

    spring.datasource.type# Fully qualified name of the connection pool implementation to use. By default, it is auto-detected from the classpath.

    spring.datasource.url# JDBC url of the database.

    spring.datasource.username=

     

    # JEST (Elasticsearch HTTP client) (JestProperties)

    spring.elasticsearch.jest.connection-timeout=3000 # Connection timeout in milliseconds.

    spring.elasticsearch.jest.password# Login password.

    spring.elasticsearch.jest.proxy.host# Proxy host the HTTP client should use.

    spring.elasticsearch.jest.proxy.port# Proxy port the HTTP client should use.

    spring.elasticsearch.jest.read-timeout=3000 # Read timeout in milliseconds.

    spring.elasticsearch.jest.uris=http://localhost:9200 # Comma-separated list of the Elasticsearch instances to use.

    spring.elasticsearch.jest.username# Login user.

     

    # H2 Web Console (H2ConsoleProperties)

    spring.h2.console.enabled=false # Enable the console.

    spring.h2.console.path=/h2-console # Path at which the console will be available.

    spring.h2.console.settings.trace=false # Enable trace output.

    spring.h2.console.settings.web-allow-others=false # Enable remote access.

     

    # JOOQ (JooqAutoConfiguration)

    spring.jooq.sql-dialect# SQLDialect JOOQ used when communicating with the configured datasource. For instance `POSTGRES`

     

    # JPA (JpaBaseConfigurationHibernateJpaAutoConfiguration)

    spring.data.jpa.repositories.enabled=true # Enable JPA repositories.

    spring.jpa.database# Target database to operate on, auto-detected by default. Can be alternatively set using the "databasePlatform" property.

    spring.jpa.database-platform# Name of the target database to operate on, auto-detected by default. Can be alternatively set using the "Database" enum.

    spring.jpa.generate-ddl=false # Initialize the schema on startup.

    spring.jpa.hibernate.ddl-auto# DDL mode. This is actually a shortcut for the "hibernate.hbm2ddl.auto" property. Default to "create-drop" when using an embedded database, "none" otherwise.

    spring.jpa.hibernate.naming.implicit-strategy# Hibernate 5 implicit naming strategy fully qualified name.

    spring.jpa.hibernate.naming.physical-strategy# Hibernate 5 physical naming strategy fully qualified name.

    spring.jpa.hibernate.naming.strategy# Hibernate 4 naming strategy fully qualified name. Not supported with Hibernate 5.

    spring.jpa.hibernate.use-new-id-generator-mappings# Use Hibernate's newer IdentifierGenerator for AUTO, TABLE and SEQUENCE.

    spring.jpa.open-in-view=true # Register OpenEntityManagerInViewInterceptor. Binds a JPA EntityManager to the thread for the entire processing of the request.

    spring.jpa.properties.*# Additional native properties to set on the JPA provider.

    spring.jpa.show-sql=false # Enable logging of SQL statements.

     

    # JTA (JtaAutoConfiguration)

    spring.jta.enabled=true # Enable JTA support.

    spring.jta.log-dir# Transaction logs directory.

    spring.jta.transaction-manager-id# Transaction manager unique identifier.

     

    # ATOMIKOS (AtomikosProperties)

    spring.jta.atomikos.connectionfactory.borrow-connection-timeout=30 # Timeout, in seconds, for borrowing connections from the pool.

    spring.jta.atomikos.connectionfactory.ignore-session-transacted-flag=true # Whether or not to ignore the transacted flag when creating session.

    spring.jta.atomikos.connectionfactory.local-transaction-mode=false # Whether or not local transactions are desired.

    spring.jta.atomikos.connectionfactory.maintenance-interval=60 # The time, in seconds, between runs of the pool's maintenance thread.

    spring.jta.atomikos.connectionfactory.max-idle-time=60 # The time, in seconds, after which connections are cleaned up from the pool.

    spring.jta.atomikos.connectionfactory.max-lifetime=0 # The time, in seconds, that a connection can be pooled for before being destroyed. 0 denotes no limit.

    spring.jta.atomikos.connectionfactory.max-pool-size=1 # The maximum size of the pool.

    spring.jta.atomikos.connectionfactory.min-pool-size=1 # The minimum size of the pool.

    spring.jta.atomikos.connectionfactory.reap-timeout=0 # The reap timeout, in seconds, for borrowed connections. 0 denotes no limit.

    spring.jta.atomikos.connectionfactory.unique-resource-name=jmsConnectionFactory # The unique name used to identify the resource during recovery.

    spring.jta.atomikos.datasource.borrow-connection-timeout=30 # Timeout, in seconds, for borrowing connections from the pool.

    spring.jta.atomikos.datasource.default-isolation-level# Default isolation level of connections provided by the pool.

    spring.jta.atomikos.datasource.login-timeout# Timeout, in seconds, for establishing a database connection.

    spring.jta.atomikos.datasource.maintenance-interval=60 # The time, in seconds, between runs of the pool's maintenance thread.

    spring.jta.atomikos.datasource.max-idle-time=60 # The time, in seconds, after which connections are cleaned up from the pool.

    spring.jta.atomikos.datasource.max-lifetime=0 # The time, in seconds, that a connection can be pooled for before being destroyed. 0 denotes no limit.

    spring.jta.atomikos.datasource.max-pool-size=1 # The maximum size of the pool.

    spring.jta.atomikos.datasource.min-pool-size=1 # The minimum size of the pool.

    spring.jta.atomikos.datasource.reap-timeout=0 # The reap timeout, in seconds, for borrowed connections. 0 denotes no limit.

    spring.jta.atomikos.datasource.test-query# SQL query or statement used to validate a connection before returning it.

    spring.jta.atomikos.datasource.unique-resource-name=dataSource # The unique name used to identify the resource during recovery.

    spring.jta.atomikos.properties.checkpoint-interval=500 # Interval between checkpoints.

    spring.jta.atomikos.properties.console-file-count=1 # Number of debug logs files that can be created.

    spring.jta.atomikos.properties.console-file-limit=-1 # How many bytes can be stored at most in debug logs files.

    spring.jta.atomikos.properties.console-file-name=tm.out # Debug logs file name.

    spring.jta.atomikos.properties.console-log-level# Console log level.

    spring.jta.atomikos.properties.default-jta-timeout=10000 # Default timeout for JTA transactions.

    spring.jta.atomikos.properties.enable-logging=true # Enable disk logging.

    spring.jta.atomikos.properties.force-shutdown-on-vm-exit=false # Specify if a VM shutdown should trigger forced shutdown of the transaction core.

    spring.jta.atomikos.properties.log-base-dir# Directory in which the log files should be stored.

    spring.jta.atomikos.properties.log-base-name=tmlog # Transactions log file base name.

    spring.jta.atomikos.properties.max-actives=50 # Maximum number of active transactions.

    spring.jta.atomikos.properties.max-timeout=300000 # Maximum timeout (in milliseconds) that can be allowed for transactions.

    spring.jta.atomikos.properties.output-dir# Directory in which to store the debug log files.

    spring.jta.atomikos.properties.serial-jta-transactions=true # Specify if sub-transactions should be joined when possible.

    spring.jta.atomikos.properties.service# Transaction manager implementation that should be started.

    spring.jta.atomikos.properties.threaded-two-phase-commit=true # Use different (and concurrent) threads for two-phase commit on the participating resources.

    spring.jta.atomikos.properties.transaction-manager-unique-name# Transaction manager's unique name.

     

    # BITRONIX

    spring.jta.bitronix.connectionfactory.acquire-increment=1 # Number of connections to create when growing the pool.

    spring.jta.bitronix.connectionfactory.acquisition-interval=1 # Time, in seconds, to wait before trying to acquire a connection again after an invalid connection was acquired.

    spring.jta.bitronix.connectionfactory.acquisition-timeout=30 # Timeout, in seconds, for acquiring connections from the pool.

    spring.jta.bitronix.connectionfactory.allow-local-transactions=true # Whether or not the transaction manager should allow mixing XA and non-XA transactions.

    spring.jta.bitronix.connectionfactory.apply-transaction-timeout=false # Whether or not the transaction timeout should be set on the XAResource when it is enlisted.

    spring.jta.bitronix.connectionfactory.automatic-enlisting-enabled=true # Whether or not resources should be enlisted and delisted automatically.

    spring.jta.bitronix.connectionfactory.cache-producers-consumers=true # Whether or not produces and consumers should be cached.

    spring.jta.bitronix.connectionfactory.defer-connection-release=true # Whether or not the provider can run many transactions on the same connection and supports transaction interleaving.

    spring.jta.bitronix.connectionfactory.ignore-recovery-failures=false # Whether or not recovery failures should be ignored.

    spring.jta.bitronix.connectionfactory.max-idle-time=60 # The time, in seconds, after which connections are cleaned up from the pool.

    spring.jta.bitronix.connectionfactory.max-pool-size=10 # The maximum size of the pool. 0 denotes no limit.

    spring.jta.bitronix.connectionfactory.min-pool-size=0 # The minimum size of the pool.

    spring.jta.bitronix.connectionfactory.password# The password to use to connect to the JMS provider.

    spring.jta.bitronix.connectionfactory.share-transaction-connections=false #  Whether or not connections in the ACCESSIBLE state can be shared within the context of a transaction.

    spring.jta.bitronix.connectionfactory.test-connections=true # Whether or not connections should be tested when acquired from the pool.

    spring.jta.bitronix.connectionfactory.two-pc-ordering-position=1 # The position that this resource should take during two-phase commit (always first is Integer.MIN_VALUE, always last is Integer.MAX_VALUE).

    spring.jta.bitronix.connectionfactory.unique-name=jmsConnectionFactory # The unique name used to identify the resource during recovery.

    spring.jta.bitronix.connectionfactory.use-tm-join=true Whether or not TMJOIN should be used when starting XAResources.

    spring.jta.bitronix.connectionfactory.user# The user to use to connect to the JMS provider.

    spring.jta.bitronix.datasource.acquire-increment=1 # Number of connections to create when growing the pool.

    spring.jta.bitronix.datasource.acquisition-interval=1 # Time, in seconds, to wait before trying to acquire a connection again after an invalid connection was acquired.

    spring.jta.bitronix.datasource.acquisition-timeout=30 # Timeout, in seconds, for acquiring connections from the pool.

    spring.jta.bitronix.datasource.allow-local-transactions=true # Whether or not the transaction manager should allow mixing XA and non-XA transactions.

    spring.jta.bitronix.datasource.apply-transaction-timeout=false # Whether or not the transaction timeout should be set on the XAResource when it is enlisted.

    spring.jta.bitronix.datasource.automatic-enlisting-enabled=true # Whether or not resources should be enlisted and delisted automatically.

    spring.jta.bitronix.datasource.cursor-holdability# The default cursor holdability for connections.

    spring.jta.bitronix.datasource.defer-connection-release=true # Whether or not the database can run many transactions on the same connection and supports transaction interleaving.

    spring.jta.bitronix.datasource.enable-jdbc4-connection-test# Whether or not Connection.isValid() is called when acquiring a connection from the pool.

    spring.jta.bitronix.datasource.ignore-recovery-failures=false # Whether or not recovery failures should be ignored.

    spring.jta.bitronix.datasource.isolation-level# The default isolation level for connections.

    spring.jta.bitronix.datasource.local-auto-commit# The default auto-commit mode for local transactions.

    spring.jta.bitronix.datasource.login-timeout# Timeout, in seconds, for establishing a database connection.

    spring.jta.bitronix.datasource.max-idle-time=60 # The time, in seconds, after which connections are cleaned up from the pool.

    spring.jta.bitronix.datasource.max-pool-size=10 # The maximum size of the pool. 0 denotes no limit.

    spring.jta.bitronix.datasource.min-pool-size=0 # The minimum size of the pool.

    spring.jta.bitronix.datasource.prepared-statement-cache-size=0 # The target size of the prepared statement cache. 0 disables the cache.

    spring.jta.bitronix.datasource.share-transaction-connections=false #  Whether or not connections in the ACCESSIBLE state can be shared within the context of a transaction.

    spring.jta.bitronix.datasource.test-query# SQL query or statement used to validate a connection before returning it.

    spring.jta.bitronix.datasource.two-pc-ordering-position=1 # The position that this resource should take during two-phase commit (always first is Integer.MIN_VALUE, always last is Integer.MAX_VALUE).

    spring.jta.bitronix.datasource.unique-name=dataSource # The unique name used to identify the resource during recovery.

    spring.jta.bitronix.datasource.use-tm-join=true Whether or not TMJOIN should be used when starting XAResources.

    spring.jta.bitronix.properties.allow-multiple-lrc=false # Allow multiple LRC resources to be enlisted into the same transaction.

    spring.jta.bitronix.properties.asynchronous2-pc=false # Enable asynchronously execution of two phase commit.

    spring.jta.bitronix.properties.background-recovery-interval-seconds=60 # Interval in seconds at which to run the recovery process in the background.

    spring.jta.bitronix.properties.current-node-only-recovery=true # Recover only the current node.

    spring.jta.bitronix.properties.debug-zero-resource-transaction=false # Log the creation and commit call stacks of transactions executed without a single enlisted resource.

    spring.jta.bitronix.properties.default-transaction-timeout=60 # Default transaction timeout in seconds.

    spring.jta.bitronix.properties.disable-jmx=false # Enable JMX support.

    spring.jta.bitronix.properties.exception-analyzer# Set the fully qualified name of the exception analyzer implementation to use.

    spring.jta.bitronix.properties.filter-log-status=false # Enable filtering of logs so that only mandatory logs are written.

    spring.jta.bitronix.properties.force-batching-enabled=true #  Set if disk forces are batched.

    spring.jta.bitronix.properties.forced-write-enabled=true # Set if logs are forced to disk.

    spring.jta.bitronix.properties.graceful-shutdown-interval=60 # Maximum amount of seconds the TM will wait for transactions to get done before aborting them at shutdown time.

    spring.jta.bitronix.properties.jndi-transaction-synchronization-registry-name# JNDI name of the TransactionSynchronizationRegistry.

    spring.jta.bitronix.properties.jndi-user-transaction-name# JNDI name of the UserTransaction.

    spring.jta.bitronix.properties.journal=disk # Name of the journal. Can be 'disk', 'null' or a class name.

    spring.jta.bitronix.properties.log-part1-filename=btm1.tlog # Name of the first fragment of the journal.

    spring.jta.bitronix.properties.log-part2-filename=btm2.tlog # Name of the second fragment of the journal.

    spring.jta.bitronix.properties.max-log-size-in-mb=2 # Maximum size in megabytes of the journal fragments.

    spring.jta.bitronix.properties.resource-configuration-filename# ResourceLoader configuration file name.

    spring.jta.bitronix.properties.server-id# ASCII ID that must uniquely identify this TM instance. Default to the machine's IP address.

    spring.jta.bitronix.properties.skip-corrupted-logs=false # Skip corrupted transactions log entries.

    spring.jta.bitronix.properties.warn-about-zero-resource-transaction=true # Log a warning for transactions executed without a single enlisted resource.

     

    # NARAYANA (NarayanaProperties)

    spring.jta.narayana.default-timeout=60 # Transaction timeout in seconds.

    spring.jta.narayana.expiry-scanners=com.arjuna.ats.internal.arjuna.recovery.ExpiredTransactionStatusManagerScanner # Comma-separated list of expiry scanners.

    spring.jta.narayana.log-dir# Transaction object store directory.

    spring.jta.narayana.one-phase-commit=true # Enable one phase commit optimisation.

    spring.jta.narayana.periodic-recovery-period=120 # Interval in which periodic recovery scans are performed in seconds.

    spring.jta.narayana.recovery-backoff-period=10 # Back off period between first and second phases of the recovery scan in seconds.

    spring.jta.narayana.recovery-db-pass# Database password to be used by recovery manager.

    spring.jta.narayana.recovery-db-user# Database username to be used by recovery manager.

    spring.jta.narayana.recovery-jms-pass# JMS password to be used by recovery manager.

    spring.jta.narayana.recovery-jms-user# JMS username to be used by recovery manager.

    spring.jta.narayana.recovery-modules# Comma-separated list of recovery modules.

    spring.jta.narayana.transaction-manager-id=1 # Unique transaction manager id.

    spring.jta.narayana.xa-resource-orphan-filters# Comma-separated list of orphan filters.

     

    # EMBEDDED MONGODB (EmbeddedMongoProperties)

    spring.mongodb.embedded.features=SYNC_DELAY # Comma-separated list of features to enable.

    spring.mongodb.embedded.storage.database-dir# Directory used for data storage.

    spring.mongodb.embedded.storage.oplog-size# Maximum size of the oplog in megabytes.

    spring.mongodb.embedded.storage.repl-set-name# Name of the replica set.

    spring.mongodb.embedded.version=2.6.10 # Version of Mongo to use.

     

    # REDIS (RedisProperties)

    spring.redis.cluster.max-redirects# Maximum number of redirects to follow when executing commands across the cluster.

    spring.redis.cluster.nodes# Comma-separated list of "host:port" pairs to bootstrap from.

    spring.redis.database=0 # Database index used by the connection factory.

    spring.redis.host=localhost # Redis server host.

    spring.redis.password# Login password of the redis server.

    spring.redis.pool.max-active=8 # Max number of connections that can be allocated by the pool at a given time. Use a negative value for no limit.

    spring.redis.pool.max-idle=8 # Max number of "idle" connections in the pool. Use a negative value to indicate an unlimited number of idle connections.

    spring.redis.pool.max-wait=-1 # Maximum amount of time (in milliseconds) a connection allocation should block before throwing an exception when the pool is exhausted. Use a negative value to block indefinitely.

    spring.redis.pool.min-idle=0 # Target for the minimum number of idle connections to maintain in the pool. This setting only has an effect if it is positive.

    spring.redis.port=6379 # Redis server port.

    spring.redis.sentinel.master# Name of Redis server.

    spring.redis.sentinel.nodes# Comma-separated list of host:port pairs.

    spring.redis.timeout=0 # Connection timeout in milliseconds.

     

     

    # ----------------------------------------

    # INTEGRATION PROPERTIES

    # ----------------------------------------

     

    # ACTIVEMQ (ActiveMQProperties)

    spring.activemq.broker-url# URL of the ActiveMQ broker. Auto-generated by default. For instance `tcp://localhost:61616`

    spring.activemq.in-memory=true # Specify if the default broker URL should be in memory. Ignored if an explicit broker has been specified.

    spring.activemq.password# Login password of the broker.

    spring.activemq.user# Login user of the broker.

    spring.activemq.packages.trust-all=false # Trust all packages.

    spring.activemq.packages.trusted# Comma-separated list of specific packages to trust (when not trusting all packages).

    spring.activemq.pool.configuration.*# See PooledConnectionFactory.

    spring.activemq.pool.enabled=false # Whether a PooledConnectionFactory should be created instead of a regular ConnectionFactory.

    spring.activemq.pool.expiry-timeout=0 # Connection expiration timeout in milliseconds.

    spring.activemq.pool.idle-timeout=30000 # Connection idle timeout in milliseconds.

    spring.activemq.pool.max-connections=1 # Maximum number of pooled connections.

     

    # ARTEMIS (ArtemisProperties)

    spring.artemis.embedded.cluster-password# Cluster password. Randomly generated on startup by default.

    spring.artemis.embedded.data-directory# Journal file directory. Not necessary if persistence is turned off.

    spring.artemis.embedded.enabled=true # Enable embedded mode if the Artemis server APIs are available.

    spring.artemis.embedded.persistent=false # Enable persistent store.

    spring.artemis.embedded.queues# Comma-separated list of queues to create on startup.

    spring.artemis.embedded.server-id# Server id. By default, an auto-incremented counter is used.

    spring.artemis.embedded.topics# Comma-separated list of topics to create on startup.

    spring.artemis.host=localhost # Artemis broker host.

    spring.artemis.mode# Artemis deployment mode, auto-detected by default.

    spring.artemis.password# Login password of the broker.

    spring.artemis.port=61616 # Artemis broker port.

    spring.artemis.user# Login user of the broker.

     

    # SPRING BATCH (BatchProperties)

    spring.batch.initializer.enabled# Create the required batch tables on startup if necessary. Enabled automatically if no custom table prefix is set or if a custom schema is configured.

    spring.batch.job.enabled=true # Execute all Spring Batch jobs in the context on startup.

    spring.batch.job.names# Comma-separated list of job names to execute on startup (For instance `job1,job2`). By default, all Jobs found in the context are executed.

    spring.batch.schema=classpath:org/springframework/batch/core/schema-@@platform@@.sql # Path to the SQL file to use to initialize the database schema.

    spring.batch.table-prefix# Table prefix for all the batch meta-data tables.

     

    # HORNETQ (HornetQProperties)

    spring.hornetq.embedded.cluster-password# Cluster password. Randomly generated on startup by default.

    spring.hornetq.embedded.data-directory# Journal file directory. Not necessary if persistence is turned off.

    spring.hornetq.embedded.enabled=true # Enable embedded mode if the HornetQ server APIs are available.

    spring.hornetq.embedded.persistent=false # Enable persistent store.

    spring.hornetq.embedded.queues# Comma-separated list of queues to create on startup.

    spring.hornetq.embedded.server-id# Server id. By default, an auto-incremented counter is used.

    spring.hornetq.embedded.topics# Comma-separated list of topics to create on startup.

    spring.hornetq.host=localhost # HornetQ broker host.

    spring.hornetq.mode# HornetQ deployment mode, auto-detected by default.

    spring.hornetq.password# Login password of the broker.

    spring.hornetq.port=5445 # HornetQ broker port.

    spring.hornetq.user# Login user of the broker.

     

    # JMS (JmsProperties)

    spring.jms.jndi-name# Connection factory JNDI name. When set, takes precedence to others connection factory auto-configurations.

    spring.jms.listener.acknowledge-mode# Acknowledge mode of the container. By default, the listener is transacted with automatic acknowledgment.

    spring.jms.listener.auto-startup=true # Start the container automatically on startup.

    spring.jms.listener.concurrency# Minimum number of concurrent consumers.

    spring.jms.listener.max-concurrency# Maximum number of concurrent consumers.

    spring.jms.pub-sub-domain=false # Specify if the default destination type is topic.

     

    # RABBIT (RabbitProperties)

    spring.rabbitmq.addresses# Comma-separated list of addresses to which the client should connect.

    spring.rabbitmq.cache.channel.checkout-timeout# Number of milliseconds to wait to obtain a channel if the cache size has been reached.

    spring.rabbitmq.cache.channel.size# Number of channels to retain in the cache.

    spring.rabbitmq.cache.connection.mode=CHANNEL # Connection factory cache mode.

    spring.rabbitmq.cache.connection.size# Number of connections to cache.

    spring.rabbitmq.connection-timeout# Connection timeout, in milliseconds; zero for infinite.

    spring.rabbitmq.dynamic=true # Create an AmqpAdmin bean.

    spring.rabbitmq.host=localhost # RabbitMQ host.

    spring.rabbitmq.listener.acknowledge-mode# Acknowledge mode of container.

    spring.rabbitmq.listener.auto-startup=true # Start the container automatically on startup.

    spring.rabbitmq.listener.concurrency# Minimum number of consumers.

    spring.rabbitmq.listener.default-requeue-rejected# Whether or not to requeue delivery failures; default `true`.

    spring.rabbitmq.listener.max-concurrency# Maximum number of consumers.

    spring.rabbitmq.listener.prefetch# Number of messages to be handled in a single request. It should be greater than or equal to the transaction size (if used).

    spring.rabbitmq.listener.retry.enabled=false # Whether or not publishing retries are enabled.

    spring.rabbitmq.listener.retry.initial-interval=1000 # Interval between the first and second attempt to deliver a message.

    spring.rabbitmq.listener.retry.max-attempts=3 # Maximum number of attempts to deliver a message.

    spring.rabbitmq.listener.retry.max-interval=10000 # Maximum interval between attempts.

    spring.rabbitmq.listener.retry.multiplier=1.0 # A multiplier to apply to the previous delivery retry interval.

    spring.rabbitmq.listener.retry.stateless=true # Whether or not retry is stateless or stateful.

    spring.rabbitmq.listener.transaction-size# Number of messages to be processed in a transaction. For best results it should be less than or equal to the prefetch count.

    spring.rabbitmq.password# Login to authenticate against the broker.

    spring.rabbitmq.port=5672 # RabbitMQ port.

    spring.rabbitmq.publisher-confirms=false # Enable publisher confirms.

    spring.rabbitmq.publisher-returns=false # Enable publisher returns.

    spring.rabbitmq.requested-heartbeat# Requested heartbeat timeout, in seconds; zero for none.

    spring.rabbitmq.ssl.enabled=false # Enable SSL support.

    spring.rabbitmq.ssl.key-store# Path to the key store that holds the SSL certificate.

    spring.rabbitmq.ssl.key-store-password# Password used to access the key store.

    spring.rabbitmq.ssl.trust-store# Trust store that holds SSL certificates.

    spring.rabbitmq.ssl.trust-store-password# Password used to access the trust store.

    spring.rabbitmq.ssl.algorithm# SSL algorithm to use. By default configure by the rabbit client library.

    spring.rabbitmq.template.mandatory=false # Enable mandatory messages.

    spring.rabbitmq.template.receive-timeout=0 # Timeout for `receive()` methods.

    spring.rabbitmq.template.reply-timeout=5000 # Timeout for `sendAndReceive()` methods.

    spring.rabbitmq.template.retry.enabled=false # Set to true to enable retries in the `RabbitTemplate`.

    spring.rabbitmq.template.retry.initial-interval=1000 # Interval between the first and second attempt to publish a message.

    spring.rabbitmq.template.retry.max-attempts=3 # Maximum number of attempts to publish a message.

    spring.rabbitmq.template.retry.max-interval=10000 # Maximum number of attempts to publish a message.

    spring.rabbitmq.template.retry.multiplier=1.0 # A multiplier to apply to the previous publishing retry interval.

    spring.rabbitmq.username# Login user to authenticate to the broker.

    spring.rabbitmq.virtual-host# Virtual host to use when connecting to the broker.

     

     

    # ----------------------------------------

    # ACTUATOR PROPERTIES

    # ----------------------------------------

     

    # ENDPOINTS (AbstractEndpoint subclasses)

    endpoints.enabled=true # Enable endpoints.

    endpoints.sensitive# Default endpoint sensitive setting.

    endpoints.actuator.enabled=true # Enable the endpoint.

    endpoints.actuator.path# Endpoint URL path.

    endpoints.actuator.sensitive=false # Enable security on the endpoint.

    endpoints.autoconfig.enabled# Enable the endpoint.

    endpoints.autoconfig.id# Endpoint identifier.

    endpoints.autoconfig.path# Endpoint path.

    endpoints.autoconfig.sensitive# Mark if the endpoint exposes sensitive information.

    endpoints.beans.enabled# Enable the endpoint.

    endpoints.beans.id# Endpoint identifier.

    endpoints.beans.path# Endpoint path.

    endpoints.beans.sensitive# Mark if the endpoint exposes sensitive information.

    endpoints.configprops.enabled# Enable the endpoint.

    endpoints.configprops.id# Endpoint identifier.

    endpoints.configprops.keys-to-sanitize=password,secret,key,token,.*credentials.*,vcap_services # Keys that should be sanitized. Keys can be simple strings that the property ends with or regex expressions.

    endpoints.configprops.path# Endpoint path.

    endpoints.configprops.sensitive# Mark if the endpoint exposes sensitive information.

    endpoints.docs.curies.enabled=false # Enable the curie generation.

    endpoints.docs.enabled=true # Enable actuator docs endpoint.

    endpoints.docs.path=/docs #

    endpoints.docs.sensitive=false #

    endpoints.dump.enabled# Enable the endpoint.

    endpoints.dump.id# Endpoint identifier.

    endpoints.dump.path# Endpoint path.

    endpoints.dump.sensitive# Mark if the endpoint exposes sensitive information.

    endpoints.env.enabled# Enable the endpoint.

    endpoints.env.id# Endpoint identifier.

    endpoints.env.keys-to-sanitize=password,secret,key,token,.*credentials.*,vcap_services # Keys that should be sanitized. Keys can be simple strings that the property ends with or regex expressions.

    endpoints.env.path# Endpoint path.

    endpoints.env.sensitive# Mark if the endpoint exposes sensitive information.

    endpoints.flyway.enabled# Enable the endpoint.

    endpoints.flyway.id# Endpoint identifier.

    endpoints.flyway.sensitive# Mark if the endpoint exposes sensitive information.

    endpoints.health.enabled# Enable the endpoint.

    endpoints.health.id# Endpoint identifier.

    endpoints.health.mapping.*# Mapping of health statuses to HttpStatus codes. By default, registered health statuses map to sensible defaults (i.e. UP maps to 200).

    endpoints.health.path# Endpoint path.

    endpoints.health.sensitive# Mark if the endpoint exposes sensitive information.

    endpoints.health.time-to-live=1000 # Time to live for cached result, in milliseconds.

    endpoints.heapdump.enabled# Enable the endpoint.

    endpoints.heapdump.path# Endpoint path.

    endpoints.heapdump.sensitive# Mark if the endpoint exposes sensitive information.

    endpoints.hypermedia.enabled=false # Enable hypermedia support for endpoints.

    endpoints.info.enabled# Enable the endpoint.

    endpoints.info.id# Endpoint identifier.

    endpoints.info.path# Endpoint path.

    endpoints.info.sensitive# Mark if the endpoint exposes sensitive information.

    endpoints.jolokia.enabled=true # Enable Jolokia endpoint.

    endpoints.jolokia.path=/jolokia # Endpoint URL path.

    endpoints.jolokia.sensitive=true # Enable security on the endpoint.

    endpoints.liquibase.enabled# Enable the endpoint.

    endpoints.liquibase.id# Endpoint identifier.

    endpoints.liquibase.sensitive# Mark if the endpoint exposes sensitive information.

    endpoints.logfile.enabled=true # Enable the endpoint.

    endpoints.logfile.external-file# External Logfile to be accessed.

    endpoints.logfile.path=/logfile # Endpoint URL path.

    endpoints.logfile.sensitive=true # Enable security on the endpoint.

    endpoints.mappings.enabled# Enable the endpoint.

    endpoints.mappings.id# Endpoint identifier.

    endpoints.mappings.path# Endpoint path.

    endpoints.mappings.sensitive# Mark if the endpoint exposes sensitive information.

    endpoints.metrics.enabled# Enable the endpoint.

    endpoints.metrics.filter.enabled=true # Enable the metrics servlet filter.

    endpoints.metrics.filter.gauge-submissions=merged # Http filter gauge submissions (merged, per-http-method)

    endpoints.metrics.filter.counter-submissions=merged # Http filter counter submissions (merged, per-http-method)

    endpoints.metrics.id# Endpoint identifier.

    endpoints.metrics.path# Endpoint path.

    endpoints.metrics.sensitive# Mark if the endpoint exposes sensitive information.

    endpoints.shutdown.enabled# Enable the endpoint.

    endpoints.shutdown.id# Endpoint identifier.

    endpoints.shutdown.path# Endpoint path.

    endpoints.shutdown.sensitive# Mark if the endpoint exposes sensitive information.

    endpoints.trace.enabled# Enable the endpoint.

    endpoints.trace.id# Endpoint identifier.

    endpoints.trace.path# Endpoint path.

    endpoints.trace.sensitive# Mark if the endpoint exposes sensitive information.

     

    # ENDPOINTS CORS CONFIGURATION (EndpointCorsProperties)

    endpoints.cors.allow-credentials# Set whether credentials are supported. When not set, credentials are not supported.

    endpoints.cors.allowed-headers# Comma-separated list of headers to allow in a request. '*' allows all headers.

    endpoints.cors.allowed-methods=GET # Comma-separated list of methods to allow. '*' allows all methods.

    endpoints.cors.allowed-origins# Comma-separated list of origins to allow. '*' allows all origins. When not set, CORS support is disabled.

    endpoints.cors.exposed-headers# Comma-separated list of headers to include in a response.

    endpoints.cors.max-age=1800 # How long, in seconds, the response from a pre-flight request can be cached by clients.

     

    # JMX ENDPOINT (EndpointMBeanExportProperties)

    endpoints.jmx.domain# JMX domain name. Initialized with the value of 'spring.jmx.default-domain' if set.

    endpoints.jmx.enabled=true # Enable JMX export of all endpoints.

    endpoints.jmx.static-names# Additional static properties to append to all ObjectNames of MBeans representing Endpoints.

    endpoints.jmx.unique-names=false # Ensure that ObjectNames are modified in case of conflict.

     

    # JOLOKIA (JolokiaProperties)

    jolokia.config.*# See Jolokia manual

     

    # MANAGEMENT HTTP SERVER (ManagementServerProperties)

    management.add-application-context-header=true # Add the "X-Application-Context" HTTP header in each response.

    management.address# Network address that the management endpoints should bind to.

    management.context-path# Management endpoint context-path. For instance `/actuator`

    management.port# Management endpoint HTTP port. Uses the same port as the application by default. Configure a different port to use management-specific SSL.

    management.security.enabled=true # Enable security.

    management.security.roles=ADMIN # Comma-separated list of roles that can access the management endpoint.

    management.security.sessions=stateless # Session creating policy to use (always, never, if_required, stateless).

    management.ssl.ciphers# Supported SSL ciphers. Requires a custom management.port.

    management.ssl.client-auth# Whether client authentication is wanted ("want") or needed ("need"). Requires a trust store. Requires a custom management.port.

    management.ssl.enabled# Enable SSL support. Requires a custom management.port.

    management.ssl.enabled-protocols# Enabled SSL protocols. Requires a custom management.port.

    management.ssl.key-alias# Alias that identifies the key in the key store. Requires a custom management.port.

    management.ssl.key-password# Password used to access the key in the key store. Requires a custom management.port.

    management.ssl.key-store# Path to the key store that holds the SSL certificate (typically a jks file). Requires a custom management.port.

    management.ssl.key-store-password# Password used to access the key store. Requires a custom management.port.

    management.ssl.key-store-provider# Provider for the key store. Requires a custom management.port.

    management.ssl.key-store-type# Type of the key store. Requires a custom management.port.

    management.ssl.protocol=TLS # SSL protocol to use. Requires a custom management.port.

    management.ssl.trust-store# Trust store that holds SSL certificates. Requires a custom management.port.

    management.ssl.trust-store-password# Password used to access the trust store. Requires a custom management.port.

    management.ssl.trust-store-provider# Provider for the trust store. Requires a custom management.port.

    management.ssl.trust-store-type# Type of the trust store. Requires a custom management.port.

     

    # HEALTH INDICATORS (previously health.*)

    management.health.db.enabled=true # Enable database health check.

    management.health.defaults.enabled=true # Enable default health indicators.

    management.health.diskspace.enabled=true # Enable disk space health check.

    management.health.diskspace.path# Path used to compute the available disk space.

    management.health.diskspace.threshold=0 # Minimum disk space that should be available, in bytes.

    management.health.elasticsearch.enabled=true # Enable elasticsearch health check.

    management.health.elasticsearch.indices# Comma-separated index names.

    management.health.elasticsearch.response-timeout=100 # The time, in milliseconds, to wait for a response from the cluster.

    management.health.jms.enabled=true # Enable JMS health check.

    management.health.mail.enabled=true # Enable Mail health check.

    management.health.mongo.enabled=true # Enable MongoDB health check.

    management.health.rabbit.enabled=true # Enable RabbitMQ health check.

    management.health.redis.enabled=true # Enable Redis health check.

    management.health.solr.enabled=true # Enable Solr health check.

    management.health.status.order=DOWN, OUT_OF_SERVICE, UP, UNKNOWN # Comma-separated list of health statuses in order of severity.

     

    # INFO CONTRIBUTORS (InfoContributorProperties)

    management.info.build.enabled=true # Enable build info.

    management.info.defaults.enabled=true # Enable default info contributors.

    management.info.env.enabled=true # Enable environment info.

    management.info.git.enabled=true # Enable git info.

    management.info.git.mode=simple # Mode to use to expose git information.

     

    # REMOTE SHELL (ShellProperties)

    management.shell.auth.type=simple # Authentication type. Auto-detected according to the environment.

    management.shell.auth.jaas.domain=my-domain # JAAS domain.

    management.shell.auth.key.path# Path to the authentication key. This should point to a valid ".pem" file.

    management.shell.auth.simple.user.name=user # Login user.

    management.shell.auth.simple.user.password# Login password.

    management.shell.auth.spring.roles=ADMIN # Comma-separated list of required roles to login to the CRaSH console.

    management.shell.command-path-patterns=classpath*:/commands/**,classpath*:/crash/commands/** # Patterns to use to look for commands.

    management.shell.command-refresh-interval=-1 # Scan for changes and update the command if necessary (in seconds).

    management.shell.config-path-patterns=classpath*:/crash/* # Patterns to use to look for configurations.

    management.shell.disabled-commands=jpa*,jdbc*,jndi* # Comma-separated list of commands to disable.

    management.shell.disabled-plugins# Comma-separated list of plugins to disable. Certain plugins are disabled by default based on the environment.

    management.shell.ssh.auth-timeout # Number of milliseconds after user will be prompted to login again.

    management.shell.ssh.enabled=true # Enable CRaSH SSH support.

    management.shell.ssh.idle-timeout # Number of milliseconds after which unused connections are closed.

    management.shell.ssh.key-path# Path to the SSH server key.

    management.shell.ssh.port=2000 # SSH port.

    management.shell.telnet.enabled=false # Enable CRaSH telnet support. Enabled by default if the TelnetPlugin is  available.

    management.shell.telnet.port=5000 # Telnet port.

     

    # TRACING (TraceProperties)

    management.trace.include=request-headers,response-headers,cookies,errors # Items to be included in the trace.

     

    # METRICS EXPORT (MetricExportProperties)

    spring.metrics.export.aggregate.key-pattern# Pattern that tells the aggregator what to do with the keys from the source repository.

    spring.metrics.export.aggregate.prefix# Prefix for global repository if active.

    spring.metrics.export.delay-millis=5000 # Delay in milliseconds between export ticks. Metrics are exported to external sources on a schedule with this delay.

    spring.metrics.export.enabled=true # Flag to enable metric export (assuming a MetricWriter is available).

    spring.metrics.export.excludes# List of patterns for metric names to exclude. Applied after the includes.

    spring.metrics.export.includes# List of patterns for metric names to include.

    spring.metrics.export.redis.key=keys.spring.metrics # Key for redis repository export (if active).

    spring.metrics.export.redis.prefix=spring.metrics # Prefix for redis repository if active.

    spring.metrics.export.send-latest# Flag to switch off any available optimizations based on not exporting unchanged metric values.

    spring.metrics.export.statsd.host# Host of a statsd server to receive exported metrics.

    spring.metrics.export.statsd.port=8125 # Port of a statsd server to receive exported metrics.

    spring.metrics.export.statsd.prefix# Prefix for statsd exported metrics.

    spring.metrics.export.triggers.*# Specific trigger properties per MetricWriter bean name.

     

     

    # ----------------------------------------

    # DEVTOOLS PROPERTIES

    # ----------------------------------------

     

    # DEVTOOLS (DevToolsProperties)

    spring.devtools.livereload.enabled=true # Enable a livereload.com compatible server.

    spring.devtools.livereload.port=35729 # Server port.

    spring.devtools.restart.additional-exclude# Additional patterns that should be excluded from triggering a full restart.

    spring.devtools.restart.additional-paths# Additional paths to watch for changes.

    spring.devtools.restart.enabled=true # Enable automatic restart.

    spring.devtools.restart.exclude=META-INF/maven/**,META-INF/resources/**,resources/**,static/**,public/**,templates/**,**/*Test.class,**/*Tests.class,git.properties # Patterns that should be excluded from triggering a full restart.

    spring.devtools.restart.poll-interval=1000 # Amount of time (in milliseconds) to wait between polling for classpath changes.

    spring.devtools.restart.quiet-period=400 # Amount of quiet time (in milliseconds) required without any classpath changes before a restart is triggered.

    spring.devtools.restart.trigger-file# Name of a specific file that when changed will trigger the restart check. If not specified any classpath file change will trigger the restart.

     

    # REMOTE DEVTOOLS (RemoteDevToolsProperties)

    spring.devtools.remote.context-path=/.~~spring-boot!~ # Context path used to handle the remote connection.

    spring.devtools.remote.debug.enabled=true # Enable remote debug support.

    spring.devtools.remote.debug.local-port=8000 # Local remote debug server port.

    spring.devtools.remote.proxy.host# The host of the proxy to use to connect to the remote application.

    spring.devtools.remote.proxy.port# The port of the proxy to use to connect to the remote application.

    spring.devtools.remote.restart.enabled=true # Enable remote restart.

    spring.devtools.remote.secret# A shared secret required to establish a connection (required to enable remote support).

    spring.devtools.remote.secret-header-name=X-AUTH-TOKEN # HTTP header used to transfer the shared secret.

     

     

     

    展开全文
  • SpringBoot入门最详细教程

    万次阅读 多人点赞 2018-02-27 11:11:23
    网上有很多springboot的入门教程,自己也因为项目要使用springboot,所以利用业余时间自学了下springboot和springcloud,使用下来发现springboot还是挺简单的,体现了极简的编程风格,大部分通用都是通过注解就可以...

    网上有很多springboot的入门教程,自己也因为项目要使用springboot,所以利用业余时间自学了下springboot和springcloud,使用下来发现springboot还是挺简单的,体现了极简的编程风格,大部分通用都是通过注解就可以完成,下面就来详细讲解下如何使用springboot来开发一个简单的restful api网关功能,可以提供给H5或者android、ios进行接口开发,还是很方便的。

    1. 使用spring initialization创建SpringBoot项目

    有很多方法可以快速创建Springboot项目,可以通过idea的springboot initialization来创建,也可以通过手工新建一个maven工程,然后引入springboot的dependency来完成sprignboot的工程导入,还可以通过spring官网的来创建springboot项目,因为有些同学可能没装idea,这里就通过官网的工程初始化指引来创建一个springboot空工程。
    首先输入网址 https://start.spring.io,打开后可以看到下图:

    image

    在serch for dependency输入web,即可完成基本的restful接口网关的功能,如果要JPA或者oauth安全相关的组件,可以增加rest repository、spring security等相关组件依赖库,spring提供的配套组件还是很多的,基本涵盖了所有应用场合。
    加入web组件后,点击下方的绿色按钮Generate Project即可创建一个springboot工程,并且自动下载到本地,接下来直接在idea或者eclipse打开该工程就可以了,在创建的时候可以选择Maven工程或者Gradle工程,这里我们使用了大家比较熟悉的Maven工程。

    2. 工程结构

    下面我们在ide中打开工程,这里使用的ide是idea,工程的目录结构为:

    image

    可以看到工程中有maven的pom文件,也自动创建了SpringbootStartApplication.java该类为springboot的启动类,待会儿我们一起看下这个类,先看下maven的pom文件有哪些。这里主要是依赖了springboot的1.4.7版本,目前最新已经更新到1.5.6了,这里没有用最新版本,还是不当小白鼠了,在dependency中依赖了spring-boot-starter-web还有个test测试的组件,如果不写测试代码,可以不使用该test组件,最后还加入了支持springboot的maven plugin组件。

        <parent>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-parent</artifactId>
            <version>1.4.7.RELEASE</version>
            <relativePath/> <!-- lookup parent from repository -->
        </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>
        </dependencies>
    
        <build>
            <plugins>
                <plugin>
                    <groupId>org.springframework.boot</groupId>
                    <artifactId>spring-boot-maven-plugin</artifactId>
                </plugin>
            </plugins>
        </build>
    

    刚看完了pom文件,在导入工程的时候,ide一般会自动导入依赖库,在国内访问maven的依赖库速度感人,建议使用阿里云的maven镜像服务器,或者使用公司的maven私服,如果公司没有私服或者自己学习可以直接使用阿里云的镜像速度还是不错的,maven setting.xml中需要添加mirror地址,具体如何配置这里就不详细描述了,可以自行百度,这里也顺便附上阿里云maven地址:

    <mirror>
        <id>nexus-aliyun</id>
        <mirrorOf>*</mirrorOf>
        <name>Nexus aliyun</name>
        <url>http://maven.aliyun.com/nexus/content/groups/public</url>
    </mirror>
    

    配置好了pom后,我们一起看下自动生成的Application.java这个类相当于我们程序的main函数入口,这里再顺便介绍下因为springboot集成了Tomcat和Jetty,默认使用Tomcat作为应用容器,开发者只需要将工程打成jar包直接丢到服务器上就可以执行了,不需要再单独部署到was、jboss、tomcat这些应用服务器上。
    SpringBootStartApplication.java

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

    所有的springboot application启动类都需要在类级别上加上@SpringBootApplication注解,其他参数不用任何调整,后续可以把一些初始化的动作放到该类中进行,目前本例中就不加其他的启动加载项了。
    这样一个api网关的架子就搭好了,是不是很简单!下面我们就可以将主要精力聚焦在业务逻辑代码上了,这里为了简化程序,不会将项目进行深入的分层设计,在实际项目中,一般都会对项目进行分层设计,如果是api网关,没有view层但是起码也会有对外接入decontroller层、处理业务逻辑的service层、处理数据持久化的dao层,同时也会有一些POJO业务实体类,这里就不详细展开了,后续也会对互联网架构设计进行详细讲述,这里我们只创建了一个UserController类,里面只有获取用户信息的方法,分别根据参数和请求方式的不同用三种方法进行了重写,下面就来一一道来。

    先来讲述下最简单的使用get请求用户信息的实现方式,代码如下,写好后直接在Application类点击右键有个RunAs,点击后会自动运行,运行成功后可以使用http发包工具进行测试,这里推荐使用chrome的postman或者使用firefox的httprequester插件,都是比较简单的发包工具,get请求的上送为http://localhost:8081/springboot/getUserByGet?userName=feiweiwei

    //@RestController注解能够使项目支持Rest
    @RestController
    @SpringBootApplication
    //表示该controller类下所有的方法都公用的一级上下文根
    @RequestMapping(value = "/springboot")
    public class UserController {
        //这里使用@RequestMapping注解表示该方法对应的二级上下文路径
        @RequestMapping(value = "/getUserByGet", method = RequestMethod.GET)
        String getUserByGet(@RequestParam(value = "userName") String userName){
            return "Hello " + userName;
        }
    }
    

    这里用到的注解主要有@RequestMapping表示请求的URL上下文路径,该路径不能重复,为了保证与团队其他同事写的不重复,一般会在每个controller前面加一个一级上下文目录,具体路径参数放在value后面,在每个方法前加一个二级目录,这样可以有效的避免路径冲突。还有注解是@RequestParam,该注解可以通过value指定入参,这里return的返回值就是实际的接口返回。

    下面介绍下POST的请求方式,可以通过在@RequestMapping注解中设置method为POST来表示该请求为POST请求,除了get、post还有put、delete等请求方式,都可以通过该参数设置。

    
        //通过RequestMethod.POST表示请求需要时POST方式
        @RequestMapping(value = "/getUserByPost", method = RequestMethod.POST)
        String getUserByPost(@RequestParam(value = "userName") String userName){
            return "Hello " + userName;
        }
    

    下面介绍下请求参数为JSON格式的请求方法的写法,这里需要注意下如果请求参数是像上面那样通过url form形式提交的请求参数,那么必须使用@RequestParam注解来标示参数,如果使用的请求报文是POST形势的JSON串,那么这里在入参的注解一定要使用@RequestBody,否则会报json解析错误。

    
        //在入参设置@RequestBody注解表示接收整个报文体,这里主要用在接收整个POST请求中的json报文体,
        //目前主流的请求报文也都是JSON格式了,使用该注解就能够获取整个JSON报文体作为入参,使用JSON解析工具解析后获取具体参数
        @RequestMapping(value = "/getUserByJson",method = RequestMethod.POST)
        String getUserByJson(@RequestBody String data){
            return "Json is " + data;
        }
    

    3. 小结

    到此一个简单的restful风格的api网关就完成了,对于移动开发人员可以自己写简单的服务端进行全栈开发了,原来做spring的同学也可以很快上手springboot,springboot总体上来说还是简化了原先复杂的配置,让大家更容易快速上手和搭建服务端,代码的git地址在下方,欢迎大家下载,谢谢。

    git代码地址:https://github.com/feiweiwei/springboot-start.git



    作者:monkey01
    链接:https://www.jianshu.com/p/af3d5800f763
    來源:简书
    著作权归作者所有。商业转载请联系作者获得授权,非商业转载请注明出处。
    展开全文
  • Spring Boot -01- 快速入门篇(图文教程)

    万次阅读 多人点赞 2018-11-28 13:31:59
    Spring Boot -01- 快速入门篇 今天开始不断整理 Spring Boot 2.0 版本学习笔记,大家可以在博客看到我的笔记,然后大家想看视频课程也可以到【慕课网】手机 app,去找【Spring Boot 2.0 深度实践】的课程,令人开心...

    Spring Boot -01- 快速入门篇(图文教程)

    今天开始不断整理 Spring Boot 2.0 版本学习笔记,大家可以在博客看到我的笔记,然后大家想看视频课程也可以到【慕课网】手机 app,去找【Spring Boot 2.0 深度实践】的课程,令人开心的是,课程完全免费!

    什么是 Spring Boot?

    在这里插入图片描述

    Spring Boot 是由 Pivotal 团队提供的全新框架。Spring Boot 是所有基于 Spring Framework 5.0 开发的项目的起点。Spring Boot 的设计是为了让你尽可能快的跑起来 Spring 应用程序并且尽可能减少你的配置文件。

    设计目的: 用来简化新 Spring 应用的初始搭建以及开发过程。

    从最根本上来讲,Spring Boot 就是一些库的集合,它能够被任意项目的构建系统所使用。它使用 “习惯优于配置” (项目中存在大量的配置,此外还内置一个习惯性的配置)的理念让你的项目快速运行起来。用大佬的话来理解,就是 spring boot 其实不是什么新的框架,它默认配置了很多框架的使用方式,就像 maven 整合了所有的 jar 包,spring boot 整合了所有的框架,总结一下及几点:

    (1)为所有 Spring 开发提供一个更快更广泛的入门体验。

    (2)零配置。无冗余代码生成和XML 强制配置,遵循“约定大于配置” 。

    (3)集成了大量常用的第三方库的配置, Spring Boot 应用为这些第三方库提供了几乎可以零配置的开箱即用的能力。

    (4)提供一系列大型项目常用的非功能性特征,如嵌入式服务器、安全性、度量、运行状况检查、外部化配置等。

    (5)Spring Boot 不是Spring 的替代者,Spring 框架是通过 IOC 机制来管理 Bean 的。Spring Boot 依赖 Spring 框架来管理对象的依赖。Spring Boot 并不是Spring 的精简版本,而是为使用 Spring 做好各种产品级准备

    Spring Boot 在应用中的角色

    Spring Boot 是基于 Spring Framework 来构建的,Spring Framework 是一种 J2EE 的框架(什么是 J2EE?
    Spring Boot 是一种快速构建 Spring 应用
    Spring Cloud 是构建 Spring Boot 分布式环境,也就是常说的云应用
    Spring Boot 中流砥柱,承上启下

    在这里插入图片描述

    环境准备

    Maven 安装与环境变量配置

    (1)Maven 安装:

    在这里插入图片描述

    (2)Maven 配置环境变量:

    解压到一个路径,然后配置环境变量:

    • 新建变量名:MAVEN_HOME 变量值:D:\server\apache-maven-3.6.0(这是我的 MAVEN 路径)
    • 编辑变量名:Path 在最前面加上:%MAVEN_HOME%\bin

    (3)检查是否配置成功:

    在命令行输入:

    mvn -V
    

    然后会一大堆东西:
    在这里插入图片描述

    (4)配置 maven 仓库:

    1.打开 maven 文件夹下的 config 文件夹下的 settings.xml;
    2.找到 localRepository 标签,此时是被注释掉的,我们解除注释,然后配置一个路径,例如:D:/space/MavenRepository/maven_jar,这样以后 MAVEN 管理下载的jar 包都会在这个路径下。
    【注意】:注意结点的位置,先找到注释掉的部分,贴在下面

    <localRepository>D:\space\MavenRepository\maven_jar</localRepository>
    

    在这里插入图片描述

    3.配置远程仓库,找到 mirrors 标签

    <!--远程仓库-->
    <mirror>
      <id>aliyun</id>
      <name>aliyun Maven</name>
      <mirrorOf>*</mirrorOf>
       <url>http://maven.aliyun.com/nexus/content/groups/public/</url>
    </mirror>
    

    在这里插入图片描述

    4.当然我们需要先建这样一个目录结构,然后还要把settings.xml 复制一份到 D:/space/MavenRepository 下

    在这里插入图片描述

    (5)在 idea 配置 maven:
    点击【File】>【Settings】>搜索【Maven】,按截图配置安装目录和选择刚刚 settings 配置文件;
    在这里插入图片描述
    选择完settings之后,本地仓库自动改成settings文件中配置的;点击apply,再点击ok即配置完成。


    使用 idea 快速搭建 Spring Boot

    第一步:新建 Spring Initializr 项目:

    在这里插入图片描述

    (1)选择 Spring Initializr
    (2)选择 SDK,点击【new】这里就是使用 JAVA SDK 要求版本 1.8+,选择你默认安装在 C:\Program Files\Java\jdk1.8.0_191 目录:
    在这里插入图片描述

    (3)然后选择默认的 url (不用管)点击【Next】:

    在这里插入图片描述

    (4)然后填写一下项目的信息:

    在这里插入图片描述

    (5)先勾选上 Web 依赖:
    在这里插入图片描述

    (6)勾选 SQl 下的 MySQL,MyBatis 依赖:
    (根据自己的项目选择,后面可加)
    在这里插入图片描述

    (7)选择好项目的位置,点击【Finish】:

    在这里插入图片描述

    (7)如果是第一次配置 Spring Boot 的话可能需要等待一会儿 IDEA 下载相应的 依赖包,默认创建好的项目结构如下:

    在这里插入图片描述

    项目结构还是看上去挺清爽的,少了很多配置文件,我们来了解一下默认生成的有什么:

    • SpringbootApplication: 一个带有 main() 方法的类,用于启动应用程序
    • SpringbootApplicationTests:一个空的 Junit 测试了,它加载了一个使用 Spring Boot 字典配置功能的 Spring 应用程序上下文
    • application.properties:一个空的 properties 文件,可以根据需要添加配置属性
    • pom.xml: Maven 构建说明文件

    第二步:HelloController

    在 【main/java/com.xpwi.springboot】包下新建一个【HelloController】:

    在这里插入图片描述

    package com.xpwi.springboot;
    
    import org.springframework.web.bind.annotation.RequestMapping;
    import org.springframework.web.bind.annotation.RestController;
    
    /**
     * 测试控制器
     *
     * @author: @肖朋伟CSDN
     * @create: 2018-11-18
     */
    @RestController
    public class HelloController {
    
        @RequestMapping("/hello")
        public String hello() {
            return "Hello Spring Boot!";
        }
    }
    

    第三步:利用 IDEA 启动 Spring Boot

    (1)我们回到 SpringbootApplication 这个类中,然后右键点击运行:

    在这里插入图片描述

    (2)会提示 Maven 导包,点击 import
    在这里插入图片描述

    (3)注意:我们之所以在上面的项目中没有手动的去配置 Tomcat 服务器,是因为 Spring Boot 内置了 Tomcat
    等待一会儿就会看到下方的成功运行的提示信息:

    在这里插入图片描述

    (4)此时,可以看到我们的 Tomcat 运行在 8080 端口,我们来访问下面地址试一下:

    http://localhost:8080/hello
    

    在这里插入图片描述

    Spring Boot 项目文件介绍

    一、解析 pom.xml 文件:

    (1)让我们来看看默认生成的 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 http://maven.apache.org/xsd/maven-4.0.0.xsd">
        <modelVersion>4.0.0</modelVersion>
    
        <groupId>com.xpwi</groupId>
        <artifactId>springboot</artifactId>
        <version>0.0.1-SNAPSHOT</version>
        <packaging>jar</packaging>
    
        <name>springboot</name>
        <description>Demo project for Spring Boot</description>
    
        <parent>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-parent</artifactId>
            <version>2.1.0.RELEASE</version>
            <relativePath/> <!-- lookup parent from repository -->
        </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>
        </dependencies>
    
        <build>
            <plugins>
                <plugin>
                    <groupId>org.springframework.boot</groupId>
                    <artifactId>spring-boot-maven-plugin</artifactId>
                </plugin>
            </plugins>
        </build>
    
    
    </project>
    
    

    (2)我们可以看到一个比较陌生一些的标签 ,这个标签是在配置 Spring Boot 的父级依赖:

    <parent>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-parent</artifactId>
            <version>2.1.0.RELEASE</version>
            <relativePath/> <!-- lookup parent from repository -->
        </parent>
    

    有了这个,当前的项目才是 Spring Boot 项目,spring-boot-starter-parent 是一个特殊的 starter ,它用来提供相关的 Maven 默认依赖,使用它之后,常用的包依赖就可以省去 version 标签。

    关于具体 Spring Boot 提供了哪些 jar 包的依赖,我们可以查看本地 Maven 仓库下:\repository\org\springframework\boot\spring-boot-dependencies\2.1.0.RELEASE\spring-boot-dependencies-2.1.0.RELEASE.pom 文件来查看,挺长的…

    二、应用入口类 SpringbootApplication.java

    Spring Boot 项目通常有一个名为 *Application 的入口类,入口类里有一个 main 方法, 这个 main 方法其实就是一个标准的 Javay 应用的入口方法。

    @SpringBootApplication 是 Spring Boot 的核心注解,它是一个组合注解,该注解组合了:@Configuration@EnableAutoConfiguration、@ComponentScan; 若不是用 @SpringBootApplication 注解也可以使用这三个注解代替。

    • 其中,@EnableAutoConfiguration 让 Spring Boot 根据类路径中的 jar 包依赖为当前项目进行自动配置,例如,添加了 spring-boot-starter-web 依赖,会自动添加 Tomcat 和 Spring MVC 的依赖,那么 Spring Boot 会对 Tomcat 和 Spring MVC 进行自动配置。
    • Spring Boot 还会自动扫描 @SpringBootApplication 所在类的同级包以及下级包里的 Bean ,所以入口类建议就配置在 grounpID + arctifactID 组合的包名下(这里为 com.xpwi.springboot 包)

    三、Spring Boot 的配置文件:

    Spring Boot 使用一个全局的配置文件 application.properties 或 application.yml,放置在【src/main/resources】目录或者类路径的 /config 下。

    Spring Boot 不仅支持常规的 properties 配置文件,还支持 yaml 语言的配置文件。yaml 是以数据为中心的语言,在配置数据的时候具有面向对象的特征。

    Spring Boot 的全局配置文件的作用是对一些默认配置的配置值进行修改。

    修改 properties 配置文件实例:

    (1)打开 resources 下的 application.properties

    在这里插入图片描述

    (2)在这里我们可以设置访问的端口,将 Tomcat 默认端口设置为 8080 (默认的不修改) ,并将默认的访问路径从 “/” 修改为 “/cn” 时,再访问 http://localhost:8080/ 是什么都没有的,此时要访问 hello 是要使用 http://localhost:8080/cn/hello

    在这里插入图片描述

    注意:如果是 yml 需要在 “:” 后加一个空格,幸好 IDEA 很好地支持了 yml 文件的格式有良好的代码提示;
    我们可以自己配置多个属性

    (3)使用 yml 文件作为配置文件,我们直接把 .properties 后缀的文件删掉,使用 .yml 文件来进行简单的配置

    在这里插入图片描述

    (4)在然后使用在我们的 HelloController.java 类中使用 @Value 来获取配置属性,代码(请看注释):

    package com.xpwi.springboot;
    
    import org.springframework.beans.factory.annotation.Value;
    import org.springframework.web.bind.annotation.RequestMapping;
    import org.springframework.web.bind.annotation.RestController;
    
    /**
     * 测试控制器
     *
     * @author: @肖朋伟CSDN
     * @create: 2018-11-18
     */
    @RestController
    public class HelloController {
    
        // 获取.yml 文件中值
        @Value("${name}")
        private String name;
    
        // 获取 age
        @Value("${csdnUrl}")
        private String csdnUrl;
    
        //路径映射,对应浏览器访问的地址,访问该路径则执行下面函数
        @RequestMapping("/hello")
        public String hello() {
            return name + " CSDN 博客:"+ csdnUrl;
        }
    }
    

    (5)重启 Spring Boot ,输入地址:http://localhost:8080/hello 能看到正确的结果:

    在这里插入图片描述

    【注意】:此时如果你第一次使用 idea 出现中文乱码,解决办法:

    在这里插入图片描述

    (6)【注意】: 我们并没有在 yml 文件中注明属性的类型,而是在使用的时候定义的。你也可以在配置文件中使用当前配置:

    在这里插入图片描述

    (7)任然可以得到正确结果:

    在这里插入图片描述

    (8)【问题】: 这样写配置文件繁琐而且可能会造成类的臃肿,因为有许许多多的 @Value 注解。

    可以,封装配置信息

    封装配置信息使用方法:

    (1)application.yml 文件内容如下:
    在这里插入图片描述

    (2)新建 author.java 和 HelloController.java 同级,内容如下:

    package com.xpwi.springboot;
    
    import org.springframework.boot.context.properties.ConfigurationProperties;
    import org.springframework.stereotype.Component;
    
    @Component
    @ConfigurationProperties(prefix = "author")
    public class author {
        private  String name;
    
        private  String csdnUrl;
    
        public String getCsdnUrl() {
            return csdnUrl;
        }
    
        public void setCsdnUrl(String csdnUrl) {
            this.csdnUrl = csdnUrl;
        }
    
        public String getName() {
            return name;
        }
    
        public void setName(String name) {
            this.name = name;
        }
    }
    
    

    (3)此时可能会报错,如果报错,打开 pom.xml 文件,添加内容(注意位置):

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

    在这里插入图片描述

    (4)重新编写 HelloController 类,内容如下:

    package com.xpwi.springboot;
    
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.beans.factory.annotation.Value;
    import org.springframework.boot.context.properties.ConfigurationProperties;
    import org.springframework.stereotype.Component;
    import org.springframework.web.bind.annotation.RequestMapping;
    import org.springframework.web.bind.annotation.RestController;
    
    /**
     * 测试控制器
     *
     * @author: @肖朋伟CSDN
     * @create: 2018-11-18
     */
    @RestController
    public class HelloController {
    
        // 获取.yml 文件中值
        //@Value("${name}")
        //private String name;
    
        // 获取 age
        //@Value("${csdnUrl}")
        //private String csdnUrl;
    
        @Autowired
        private author author;
    
        //路径映射,对应浏览器访问的地址,访问该路径则执行下面函数
        @RequestMapping("/hello")
        public String hello() {
            return "名字:" + author.getName() + " 地址:" + author.getCsdnUrl();
        }
    }
    

    (5)重启 Spring Boot,访问浏览器:

    http://localhost:8080/hello
    

    在这里插入图片描述

    【提示】:我们可以把配置信息封装成一个类,首先在我们的 name 和 age 前加一个 student 前缀,然后新建一个 StudentProperties 的类用来封装这些信息,并用上两个注解:

    • @Component:表明当前类是一个 Java Bean
    • @ConfigurationProperties(prefix = “author”):表示获取前缀为 author 的配置信息

    转载请注明出处:肖朋伟:https://blog.csdn.net/qq_40147863/article/details/84194493

    更多文章链接:

    展开全文
  • Springboot简单介绍

    万次阅读 多人点赞 2019-01-29 09:03:49
    Springboot入门介绍 一、Spring框架概述 1.1 什么是Spring Spring是一个开源框架,Spring是于2003 年兴起的一个轻量级的Java 开发框架,由Rod Johnson 在其著作《Expert One-On-One J2EE Development and Design...

    Springboot入门介绍

    一、Spring框架概述

    1.1 什么是Spring

    Spring是一个开源框架,Spring是于2003 年兴起的一个轻量级的Java 开发框架,由Rod Johnson 在其著作《Expert One-On-One J2EE Development and Design》。Spring是为了解决企业级应用开发的复杂性而创建的,使用Spring可以让简单的JavaBean实现之前只有EJB才能完成的事情。但是Spring不仅仅局限于服务器端开发,任何Java应用都能在简单性、可测试性和松耦合性等方面从Spring中获益。

    1.2 Spring是如何简化Java开发的

    为了降低Java开发的复杂性,Spring采用了以下4种关键策略:

    1、基于POJO的轻量级和最小侵入性编程;

    2、通过依赖注入(DI)和面向接口实现松耦合;

    3、基于切面(AOP)和惯例进行声明式编程;

    4、通过切面和模版减少样式代码;

     

    二、SpringBoot简介

    2.1什么是SpringBoot

    Spring Boot 是所有基于 Spring 开发的项目的起点。Spring Boot 的设计是为了让你尽可能快的跑起来 Spring 应用程序并且尽可能减少你的配置文件。简单来说就是SpringBoot其实不是什么新的框架,它默认配置了很多框架的使用方式,就像maven整合了所有的jar包,spring boot整合了所有的框架(不知道这样比喻是否合适)。

    2.2、SpringBoot四个主要特性

    1SpringBoot Starter:他将常用的依赖分组进行了整合,将其合并到一个依赖中,这样就可以一次性添加到项目的MavenGradle构建中;

    2、自动配置:SpringBoot的自动配置特性利用了Spring4对条件化配置的支持,合理地推测应用所需的bean并自动化配置他们;

    3、命令行接口:(Command-line-interface, CLI):SpringBootCLI发挥了Groovy编程语言的优势,并结合自动配置进一步简化Spring应用的开发;

    4Actuatir:它为SpringBoot应用的所有特性构建一个小型的应用程序。但首先,我们快速了解每项特性,更好的体验他们如何简化Spring编程模型。

    2.3 SpringBoot开发的具体好处

    回顾我们之前的 SSM 项目,搭建过程还是比较繁琐的,需要:

    1、配置web.xml,加载springspring mvc

    2、配置数据库连接、配置spring事务

    3、配置加载配置文件的读取,开启注解

    。。。

    配置完成之后部署tomcat 调试

    而使用 Spring Boot 来开发项目则只需要非常少的几个配置就可以搭建起来一个 Web 项目,并且利用 IDEA 可以自动生成生成,这简直是太爽了...

    华丽的分割线----------------------------------------------------------------------------------------------------

    三、使用IDEA快速搭建SpringBoot项目

    1file->new project 在弹出的窗口选择Spring Initializr

    2、修改项目信息

    3、选择版本及项目需要的依赖

    4、最终目录结构

     

    项目结构还是看上去挺清爽的,少了很多配置文件,我们来了解一下默认生成的有什么:

    • EurekaServerApplication 一个带有 main() 方法的类,用于启动应用程序
    • EurekaServerApplicationTests:一个空的 Junit 测试了,它加载了一个使用 Spring Boot 字典配置功能的 Spring 应用程序上下文
    • application.properties:一个空的 properties 文件,可以根据需要添加配置属性
    • pom.xml Maven 构建说明文件
    •  

    四、项目简单介绍及helloworld编写

    4.1、写一个helloWorld接口

    @RestController
    @RequestMapping("/")
    public class HelloWorldController {
        @RequestMapping("hello")
        public String index() {
            return "Hello World";
        }
    }

    @RestController 注解: 该注解是 @Controller @ResponseBody 注解的合体版

     

    4.2、单元测试

    @RunWith(SpringRunner.class)
    @SpringBootTest
    public class ServiceAuthApplicationTests {
       private MockMvc mvc;
       @Before
       public void setUp() {
          mvc = MockMvcBuilders.standaloneSetup(new HelloController()).build();
       }
       @Test
       public void contextLoads() throws Exception {
                    mvc.perform(MockMvcRequestBuilders.get("/hello").accept(
    
            MediaType.APPLICATION_JSON))
                .andExpect(MockMvcResultMatchers.status().isOk())
                .andDo(MockMvcResultHandlers.print())
                .andReturn();
       }
    }

     

    4.3pom文件介绍

    <?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>
    
    
        <groupId>com.test</groupId>
        <artifactId>springboot</artifactId>
        <version>1.0-SNAPSHOT</version>
        <packaging>pom</packaging>
    
    
    
    
        <name>spring-cloud-demo</name>
    
        <description>Demo project for Spring Boot</description>
    
        <parent>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-parent</artifactId>
            <version>1.5.18.BUILD-SNAPSHOT</version>
            <relativePath/> <!-- lookup parent from repository -->
        </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>
    
        <build>
            <plugins>
                <plugin>
                    <groupId>org.springframework.boot</groupId>
                    <artifactId>spring-boot-maven-plugin</artifactId>
                </plugin>
            </plugins>
        </build>
    
        <repositories>
            <repository>
                <id>spring-snapshots</id>
                <name>Spring Snapshots</name>
                <url>https://repo.spring.io/snapshot</url>
                <snapshots>
                    <enabled>true</enabled>
                </snapshots>
            </repository>
    
            <repository>
                <id>spring-milestones</id>
                <name>Spring Milestones</name>
                <url>https://repo.spring.io/milestone</url>
                <snapshots>
                    <enabled>false</enabled>
                </snapshots>
            </repository>
        </repositories>
    
    
        <pluginRepositories>
    
            <pluginRepository>
                <id>spring-snapshots</id>
                <name>Spring Snapshots</name>
                <url>https://repo.spring.io/snapshot</url>
                <snapshots>
                    <enabled>true</enabled>
                </snapshots>
            </pluginRepository>
    
            <pluginRepository>
                <id>spring-milestones</id>
                <name>Spring Milestones</name>
                <url>https://repo.spring.io/milestone</url>
                <snapshots>
                    <enabled>false</enabled>
                </snapshots>
            </pluginRepository>
        </pluginRepositories>
    
    </project>
     
    

    这个标签是在配置 Spring Boot 的父级依赖

    有了这个,当前的项目才是 Spring Boot 项目,spring-boot-starter-parent 是一个特殊的 starter ,它用来提供相关的 Maven 默认依赖,使用它之后,常用的包依赖就可以省去 version 标签。

     

    4.4、启动类介绍(*Application

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

    @SpringBootApplicationspringBoot的核心注解注解: 该注解是@Configuration@EnableAutoConfiguration@ComponentScan 注解的合体版

     

    4.5. properties介绍

    springBoot 使用一个全局的配置文件 application.properties application.yml,放置在【src/main/resources】目录

    Tomcat 默认端口设置为 9090 ,并将默认的访问路径从 / 修改为 /test 时,使用 properties 文件

    展开全文
  • SpringBoot Security前后端分离登录验证

    千次阅读 2020-07-02 17:40:00
    SpringBoot Security前后端分离登录验证 本文是转载的。写的非常好,简单易懂 最近一段时间在研究OAuth2的使用,想整个单点登录,从网上找了很多demo都没有实施成功,也许是因为压根就不懂OAuth2的原理导致。有...
  • Springboot + Spring Security 实现前后端分离登录认证及权限控制前言本文主要的功能文章目录一、数据库表设计建表语句初始化表数据语句二、Spring Security核心配置:WebSecurityConfig三、用户登录认证逻辑:...
  • Springboot之初识Spring Security什么是Spring Security初识Security具体代码实现1 引入Security包2 创建Security配置类3 创建UserInfo类4 实现UserDetailsService提供一个登录接口 什么是Spring Security Spring ...
  • 一、Spring Boot简介 Spring Boot是由Pivotal团队提供的全新框架,其设计目的是用来简化新Spring应用的初始搭建以及开发过程。该框架使用了特定的方式来进行配置,从而使开发人员不再需要定义样板化的配置。...
  • Spring和SpringBoot比较,解惑区别

    万次阅读 多人点赞 2019-04-02 17:58:58
    对于Spring和SpringBoot到底有什么区别,我听到了很多答案,刚开始迈入学习SpringBoot的我当时也是一头雾水,随着经验的积累、我慢慢理解了这两个框架到底有什么区别,我相信对于用了SpringBoot很久的开发人员来说,...
  • SpringBoot学习历程

    万次阅读 多人点赞 2019-07-04 14:02:28
    新年新气象,更新了一下本人所有写的关于SpringBoot的文章目录,感谢大家长期以来的支持,在接下来的日子还会不定期的进行更新。 入门 使用IntelliJ Idea新建SpringBoot项目 SpringBoot启动banner更改 ...
  • SpringBoot学习目录

    万次阅读 多人点赞 2019-11-23 09:38:26
    SpringBoot目录 SpringBoot 入门篇 SpringBoot Web篇 SpringBoot Redis 篇 SpringBoot Mybatis篇 SpringBoot RabbitMQ篇 SpringBoot的定时器 SpringBoot集成邮件服务 SpringBoot 集成MongoDB SpringBoot 集成Shiro ...
  • SpringBoot企业级应用实战

    万次阅读 多人点赞 2019-09-22 17:05:56
    SpringBoot企业级应用实战 基础教程 SpringBoot 快速入门 SpringBoot快速入门,不继承SpringBoot父依赖项目 SpringBoot集成MyBatis SpringBoot热部署 SpringBoot整合freemarker SpringBoot整合模板引擎...
  • SpringBoot非官方教程 | 终章:文章汇总

    万次阅读 多人点赞 2020-06-08 18:29:19
    转载请标明出处: ... 本文出自方志朋的博客 ...springboot非官方教程,可能最接近于官方的一个教程,大多数案例都来自于官方文档,为了更好的理解,加入了个人的改造。 码云下载:https://git.oschina...
  • springboot教程目录

    万次阅读 2018-09-18 18:23:36
    springboot初体验 springboot属性配置文件详解 springboot日志[logback、log4j、log4j2] web基础 springboot集成模板引擎实现web应用 springboot统一异常处理 springboot自定义视图映射 插件集成 springboot...
  • springboot2系列技术教程目录

    万次阅读 2019-06-28 13:39:46
    springboot系列教程,参考网上现有的资料整理的。如果错误或者更好的相应内容可以留言。 每个主题都有相应的源码。源码地址 基于springboot2.1版本讲解 Springboot2(1)日志配置和动态日志等级设置 ...
  • springboot框架图解

    万次阅读 多人点赞 2019-06-12 14:53:23
    springboot容器启动流程: 其中最重要的: 运行机制为: springboot事件驱动:详情见:springboot事件驱动与观察者模式(http://www.cnblogs.com/dennyzhangdd/p/8343229.html) springboot启动流程图: ...
  • springboot获取当前项目路径的地址

    万次阅读 2018-09-05 18:02:20
    new ApplicationHome(this.getClass()).getSource().getParentFile().getParentFile().getPath()
  • HttpServletRequest request = ((ServletRequestAttributes) RequestContextHolder.getRequestAttributes()).getRequest(); HttpSession session = request.getSession();
  • springboot项目启动后 直接停止

    万次阅读 2018-08-16 18:26:30
    Process finished with exit code 0 可能原因:yml文件空格导致
1 2 3 4 5 ... 20
收藏数 413,422
精华内容 165,368
关键字:

springboot