springboot

Spring boot

Spring Boot是由Pivotal团队提供的全新框架，其设计目的是用来简化新Spring应用的初始搭建以及开发过程。该框架使用了特定的方式来进行配置，从而使开发人员不再需要定义样板化的配置。通过这种方式，Boot致力于在蓬勃发展的快速应用开发领域（rapid application development）成为领导者。

从最根本上来讲，Spring Boot就是一些库的集合，它能够被任意项目的构建系统所使用。简便起见，该框架也提供了命令行界面，它可以用来运行和测试Boot应用。框架的发布版本，包括集成的CLI（命令行界面），可以在Spring仓库中手动下载和安装。一种更为简便的方式是使用Groovy环境管理器（Groovy enVironment Manager，GVM），它会处理Boot版本的安装和管理。Boot及其CLI可以通过GVM的命令行gvm install springboot进行安装。

Eclipse 依赖tomcat时附加：

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

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

<scope>provided</scope>

</dependency>

<groupId>org.apache.tomcat.embed</groupId>

<artifactId>tomcat-embed-jasper</artifactId>

<scope>provided</scope>

</dependency>

Idea 依赖tomcat时附加：provided在idea中不能被依赖bug

<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-tomcat</artifactId>
</dependency>
<dependency>
<groupId>org.apache.tomcat.embed</groupId>
<artifactId>tomcat-embed-jasper</artifactId>
</dependency>

Springboot 依赖jpa时注意点：

.properties配置文件:

########################################################
### Java Persistence Api \u81EA\u52A8\u8FDB\u884C\u5EFA\u8868
########################################################
# Specify the DBMS
spring.jpa.database = MYSQL
# Show or not log for each sql query
spring.jpa.show-sql = true
# Hibernate ddl auto (create, create-drop, update)
spring.jpa.hibernate.ddl-auto = update
# Naming strategy
spring.jpa.hibernate.naming-strategy = org.hibernate.cfg.ImprovedNamingStrategy
# stripped before adding them to the entity manager)
spring.jpa.properties.hibernate.dialect = org.hibernate.dialect.MySQL5Dialect

实体类自动生成数据表：注意Entity和Id和GeneratedValue导包问题。

import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.Id;
import java.io.Serializable;

@Entity
public class DemoInfo implements Serializable {
    private static final long serialVersionUID = 1L;
    @Id
    @GeneratedValue
    private long id;
    private String name;
    private String pwd;

导错包会出现以下错误：

Maven 依赖

Parent 父类

在pom.xml中引入spring-boot-start-parent,spring官方的解释叫什么staterpoms,它可以提供dependency management,也就是说依赖管理，引入以后在申明其它dependency的时候就不需要version了，后面可以看到。

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

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

<version>1.3.3.RELEASE</version>

</parent>

web依赖：

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

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

</dependency>

</dependencies>

如果直接maven启动添加plugin：

<build>

    <plugins>

           <plugin>

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

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

          </plugin>

      </plugins>

  </build>

Mysql依赖：

<groupId>mysql</groupId>

<artifactId>mysql-connector-Java</artifactId>

</dependency>

Redis 依赖：

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

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

</dependency>

Mybatis依赖:

<dependency>
    <groupId>org.mybatis.spring.boot</groupId>
    <artifactId>mybatis-spring-boot-starter</artifactId>
    <version>1.1.1</version>
</dependency>

Hibernate jpa依赖：

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

<artifactId>spring-boot-starter-data-jpa</artifactId>

</dependency>

MyBatis分页依赖：

<dependency>
    <groupId>com.github.pagehelper</groupId>
    <artifactId>pagehelper</artifactId>
    <version>4.1.0</version>
</dependency>

Jdk依赖：

Aop依赖：

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

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

</dependency>

Mail邮件依赖：

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

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

</dependency>

Test 依赖：<scope>test</scope>在idea中不需要

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

Lo4fj 日志依赖：

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

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

</dependency>

Thymeleaf 依赖：

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

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

</dependency>

Mongodb 依赖：

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

<artifactId>spring-boot-starter-data-mongodb</artifactId>

</dependency>

RebbitMQ 依赖：

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

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

</dependency>

ActiveMQ 依赖：

这里是引入了activemq的依赖，在这里需要注意下spring boot的版本是1.4.0之前的大部分的例子都是1.3.3的，这里必须是1.4+不然是不支持activemq。

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

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

</dependency>

注解说明：

1：@RestController

Spring4 的新注解：注解本身使用@Controller和@ResponseBody注解。使用了这个注解的类会被看作一个controller-使用@RequestMapping的方法有一个默认的@ResponseBody注解。

2：@SpringBootApplication

由于大量项目都会在主要的配置类上添加@Configuration,@EnableAutoConfiguration,@ComponentScan三个注解。因此Spring Boot提供了@SpringBootApplication注解，该注解可以替代上面三个注解（使用Spring注解继承实现）。

3：@EnableAutoConfiguration

Spring Boot建议只有一个带有该注解的类。

@EnableAutoConfiguration作用：Spring Boot会自动根据你jar包的依赖来自动配置项目。例如当你项目下面有HSQLDB的依赖时，Spring Boot会创建默认的内存数据库的数据源DataSource，如果你自己创建了DataSource，Spring Boot就不会创建默认的DataSource。

4：@ComponentScan

表示将该类自动发现（扫描）并注册为Bean，可以自动收集所有的Spring组件，包括@Configuration类。我们经常使用@ComponentScan注解搜索beans，并结合@Autowired注解导入。如果没有配置的话，Spring Boot会扫描启动类所在包下以及子包下的使用了@Service,@Repository等注解的类。

5：@Configuration

相当于传统的xml配置文件，如果有些第三方库需要用到xml文件，建议仍然通过@Configuration类作为项目的配置主类——可以使用@ImportResource注解加载xml配置文件。

6：@Import

用来导入其他配置类。

7：@ImportResource

用来加载xml配置文件。

8：@Repository

使用@Repository注解可以确保DAO或者repositories提供异常转译，这个注解修饰的DAO或者repositories类会被ComponetScan发现并配置，同时也不需要为它们提供XML配置项。

9：@Bean

用@Bean标注方法等价于XML中配置的bean。

10：@Qualifier

@Qualifier限定描述符除了能根据名字进行注入，但能进行更细粒度的控制如何选择候选者，具体使用方式如下：

@Autowired

@Qualifier(value = "demoInfoService")

private DemoInfoService demoInfoService;

11：@Inject

等价于默认的@Autowired，只是没有required属性

12：@ResponseBody

该注解修饰的函数，会将结果直接填充到HTTP的响应体中，一般用于构建RESTful的api，该注解一般会配合@RequestMapping一起使用。

@RequestMapping("/test")

@ResponseBody

public String test(){

return"ok";

}

13：@Controller

用于定义控制器类，在spring 项目中由控制器负责将用户发来的URL请求转发到对应的服务接口（service层），一般这个注解在类中，通常方法需要配合注解@RequestMapping。

@Controller

@RequestMapping("/demoInfo")

publicclass DemoController {

@Autowired

private DemoInfoService demoInfoService;

@RequestMapping("/hello")

public String hello(Map<String,Object> map){

System.out.println("DemoController.hello()");

map.put("hello","from TemplateController.helloHtml");

//会使用hello.html或者hello.ftl模板进行渲染显示.

return"/hello";

}

14：@ConfigurationProperties

Properties代码

wisely2.name=wyf2
wisely2.gender=male2

自定义配置文件名：

@ConfigurationProperties(prefix = "wisely2")
public class Wisely2Settings {
private String name;
private String gender;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
10. }
11. public String getGender() {
12. return gender;
13. }
14. public void setGender(String gender) {
15. this.gender = gender;
16. }
17.

18. }

15：@EnableConfigurationProperties

自动映射一个POJO到Spring Boot配置文件（默认是application.properties文件）的属性集。

16：@ ConfigurationProperties

注释将POJO关联到指定前缀的每一个属性。例如，spring.data.mongodb.port属性将映射到这个类的端口属性。

强烈建议Spring Boot开发者使用这种方式来删除与配置属性相关的瓶颈代码。

@ConfigurationProperties(prefix = "spring.data.mongodb")

public class MongoProperties {

private String host;

private int port = DBPort.PORT;

private String uri = "mongodb://localhost/test";

private String database;

// ... getters/ setters omitted

}

启动类：

1：例如main 启动类：Applicatio.java

public static void main(String[] args) {

    SpringApplication.run(Application.class,args);

}:

2：通过java代码更改启动端口：

@RestController

@SpringBootApplication

public class Application extends SpringBootServletInitializer implements EmbeddedServletContainerCustomizer{

    @RequestMapping("/")

    public String hello(){

        return "hello word";

    }



    public static void main(String[] args) {

        SpringApplication.run(Application.class,args);

    }



    @Override

    public void customize(ConfigurableEmbeddedServletContainer container) {

        container.setPort(8081);

    }



    protected SpringApplicationBuilder configure(SpringApplicationBuilder builder){

        return builder.sources(Application.class);

    }

}

.yml或.properties配置属性

默认文件名字：application.properties路径是src/main/resources下

1：配置文件属性：

mvc

spring.mvc.async.request-timeout
设定async请求的超时时间，以毫秒为单位，如果没有设置的话，以具体实现的超时时间为准，比如tomcat的servlet3的话是10秒.
spring.mvc.date-format
设定日期的格式，比如dd/MM/yyyy.
spring.mvc.favicon.enabled
是否支持favicon.ico，默认为: true
spring.mvc.ignore-default-model-on-redirect
在重定向时是否忽略默认model的内容，默认为true
spring.mvc.locale
指定使用的Locale.
spring.mvc.message-codes-resolver-format
指定message codes的格式化策略(PREFIX_ERROR_CODE,POSTFIX_ERROR_CODE).
spring.mvc.view.prefix
指定mvc视图的前缀.
spring.mvc.view.suffix
指定mvc视图的后缀.
spring.messages.basename
指定message的basename，多个以逗号分隔，如果不加包名的话，默认从classpath路径开始，默认: messages
spring.messages.cache-seconds
设定加载的资源文件缓存失效时间，-1的话为永不过期，默认为-1
spring.messages.encoding
设定Message bundles的编码，默认: UTF-8
spring.mobile.devicedelegatingviewresolver.enable-fallback
是否支持fallback的解决方案，默认false
spring.mobile.devicedelegatingviewresolver.enabled
是否开始device view resolver，默认为: false
spring.mobile.devicedelegatingviewresolver.mobile-prefix
设定mobile端视图的前缀，默认为:mobile/
spring.mobile.devicedelegatingviewresolver.mobile-suffix
设定mobile视图的后缀
spring.mobile.devicedelegatingviewresolver.normal-prefix
设定普通设备的视图前缀
spring.mobile.devicedelegatingviewresolver.normal-suffix
设定普通设备视图的后缀
spring.mobile.devicedelegatingviewresolver.tablet-prefix
设定平板设备视图前缀，默认:tablet/
spring.mobile.devicedelegatingviewresolver.tablet-suffix
设定平板设备视图后缀.
spring.mobile.sitepreference.enabled
是否启用SitePreferenceHandler，默认为: true
spring.view.prefix
设定mvc视图的前缀.
spring.view.suffix
设定mvc视图的后缀.
spring.resources.add-mappings
是否开启默认的资源处理，默认为true
spring.resources.cache-period
设定资源的缓存时效，以秒为单位.
spring.resources.chain.cache
是否开启缓存，默认为: true
spring.resources.chain.enabled
是否开启资源 handling chain，默认为false
spring.resources.chain.html-application-cache
是否开启h5应用的cache manifest重写，默认为: false
spring.resources.chain.strategy.content.enabled
是否开启内容版本策略，默认为false
spring.resources.chain.strategy.content.paths
指定要应用的版本的路径，多个以逗号分隔，默认为:[/**]
spring.resources.chain.strategy.fixed.enabled
是否开启固定的版本策略，默认为false
spring.resources.chain.strategy.fixed.paths
指定要应用版本策略的路径，多个以逗号分隔
spring.resources.chain.strategy.fixed.version
指定版本策略使用的版本号
spring.resources.static-locations
指定静态资源路径，默认为classpath:[/META-INF/resources/,/resources/, /static/, /public/]以及context:/
multipart.enabled
是否开启文件上传支持，默认为true
multipart.file-size-threshold
设定文件写入磁盘的阈值，单位为MB或KB，默认为0
multipart.location
指定文件上传路径.
multipart.max-file-size
指定文件大小最大值，默认1MB
multipart.max-request-size
指定每次请求的最大值，默认为10MB
spring.freemarker.allow-request-override
指定HttpServletRequest的属性是否可以覆盖controller的model的同名项
spring.freemarker.allow-session-override
指定HttpSession的属性是否可以覆盖controller的model的同名项
spring.freemarker.cache
是否开启template caching.
spring.freemarker.charset
设定Template的编码.
spring.freemarker.check-template-location
是否检查templates路径是否存在.
spring.freemarker.content-type
设定Content-Type.
spring.freemarker.enabled
是否允许mvc使用freemarker.
spring.freemarker.expose-request-attributes
设定所有request的属性在merge到模板的时候，是否要都添加到model中.
spring.freemarker.expose-session-attributes
设定所有HttpSession的属性在merge到模板的时候，是否要都添加到model中.
spring.freemarker.expose-spring-macro-helpers
设定是否以springMacroRequestContext的形式暴露RequestContext给Spring’s macro library使用
spring.freemarker.prefer-file-system-access
是否优先从文件系统加载template，以支持热加载，默认为true
spring.freemarker.prefix
设定freemarker模板的前缀.
spring.freemarker.request-context-attribute
指定RequestContext属性的名.
spring.freemarker.settings
设定FreeMarker keys.
spring.freemarker.suffix
设定模板的后缀.
spring.freemarker.template-loader-path
设定模板的加载路径，多个以逗号分隔，默认: ["classpath:/templates/"]
spring.freemarker.view-names
指定使用模板的视图列表.
spring.velocity.allow-request-override
指定HttpServletRequest的属性是否可以覆盖controller的model的同名项
spring.velocity.allow-session-override
指定HttpSession的属性是否可以覆盖controller的model的同名项
spring.velocity.cache
是否开启模板缓存
spring.velocity.charset
设定模板编码
spring.velocity.check-template-location
是否检查模板路径是否存在.
spring.velocity.content-type
设定ContentType的值
spring.velocity.date-tool-attribute
设定暴露给velocity上下文使用的DateTool的名
spring.velocity.enabled
设定是否允许mvc使用velocity
spring.velocity.expose-request-attributes
是否在merge模板的时候，将request属性都添加到model中
spring.velocity.expose-session-attributes
是否在merge模板的时候，将HttpSession属性都添加到model中
spring.velocity.expose-spring-macro-helpers
设定是否以springMacroRequestContext的名来暴露RequestContext给Spring’s macro类库使用
spring.velocity.number-tool-attribute
设定暴露给velocity上下文的NumberTool的名
spring.velocity.prefer-file-system-access
是否优先从文件系统加载模板以支持热加载，默认为true
spring.velocity.prefix
设定velocity模板的前缀.
spring.velocity.properties
设置velocity的额外属性.
spring.velocity.request-context-attribute
设定RequestContext attribute的名.
spring.velocity.resource-loader-path
设定模板路径，默认为: classpath:/templates/
spring.velocity.suffix
设定velocity模板的后缀.
spring.velocity.toolbox-config-location
设定Velocity Toolbox配置文件的路径，比如 /WEB-INF/toolbox.xml.
spring.velocity.view-names
设定需要解析的视图名称.
spring.thymeleaf.cache
是否开启模板缓存，默认true
spring.thymeleaf.check-template-location
是否检查模板路径是否存在，默认true
spring.thymeleaf.content-type
指定Content-Type，默认为: text/html
spring.thymeleaf.enabled
是否允许MVC使用Thymeleaf，默认为: true
spring.thymeleaf.encoding
指定模板的编码，默认为: UTF-8
spring.thymeleaf.excluded-view-names
指定不使用模板的视图名称，多个以逗号分隔.
spring.thymeleaf.mode
指定模板的模式，具体查看StandardTemplateModeHandlers，默认为: HTML5
spring.thymeleaf.prefix
指定模板的前缀，默认为:classpath:/templates/
spring.thymeleaf.suffix
指定模板的后缀，默认为:.html
spring.thymeleaf.template-resolver-order
指定模板的解析顺序，默认为第一个.
spring.thymeleaf.view-names
指定使用模板的视图名，多个以逗号分隔.
spring.mustache.cache
是否Enable template caching.
spring.mustache.charset
指定Template的编码.
spring.mustache.check-template-location
是否检查默认的路径是否存在.
spring.mustache.content-type
指定Content-Type.
spring.mustache.enabled
是否开启mustcache的模板支持.
spring.mustache.prefix
指定模板的前缀，默认: classpath:/templates/
spring.mustache.suffix
指定模板的后缀，默认: .html
spring.mustache.view-names
指定要使用模板的视图名.
spring.groovy.template.allow-request-override
指定HttpServletRequest的属性是否可以覆盖controller的model的同名项
spring.groovy.template.allow-session-override
指定HttpSession的属性是否可以覆盖controller的model的同名项
spring.groovy.template.cache
是否开启模板缓存.
spring.groovy.template.charset
指定Template编码.
spring.groovy.template.check-template-location
是否检查模板的路径是否存在.
spring.groovy.template.configuration.auto-escape
是否在渲染模板时自动排查model的变量，默认为: false
spring.groovy.template.configuration.auto-indent
是否在渲染模板时自动缩进，默认为false
spring.groovy.template.configuration.auto-indent-string
如果自动缩进启用的话，是使用SPACES还是TAB，默认为: SPACES
spring.groovy.template.configuration.auto-new-line
渲染模板时是否要输出换行，默认为false
spring.groovy.template.configuration.base-template-class
指定template base class.
spring.groovy.template.configuration.cache-templates
是否要缓存模板，默认为true
spring.groovy.template.configuration.declaration-encoding
在写入declaration header时使用的编码
spring.groovy.template.configuration.expand-empty-elements
是使用<br/>这种形式，还是<br></br>这种展开模式，默认为: false)
spring.groovy.template.configuration.locale
指定template locale.
spring.groovy.template.configuration.new-line-string
当启用自动换行时，换行的输出，默认为系统的line.separator属性的值
spring.groovy.template.configuration.resource-loader-path
指定groovy的模板路径，默认为classpath:/templates/
spring.groovy.template.configuration.use-double-quotes
指定属性要使用双引号还是单引号，默认为false
spring.groovy.template.content-type
指定Content-Type.
spring.groovy.template.enabled
是否开启groovy模板的支持.
spring.groovy.template.expose-request-attributes
设定所有request的属性在merge到模板的时候，是否要都添加到model中.
spring.groovy.template.expose-session-attributes
设定所有request的属性在merge到模板的时候，是否要都添加到model中.
spring.groovy.template.expose-spring-macro-helpers
设定是否以springMacroRequestContext的形式暴露RequestContext给Spring’s macro library使用
spring.groovy.template.prefix
指定模板的前缀.
spring.groovy.template.request-context-attribute
指定RequestContext属性的名.
spring.groovy.template.resource-loader-path
指定模板的路径，默认为: classpath:/templates/
spring.groovy.template.suffix
指定模板的后缀
spring.groovy.template.view-names
指定要使用模板的视图名称.
spring.hateoas.apply-to-primary-object-mapper
设定是否对object mapper也支持HATEOAS，默认为: true
spring.http.converters.preferred-json-mapper
是否优先使用JSON mapper来转换.
spring.http.encoding.charset
指定http请求和相应的Charset，默认: UTF-8
spring.http.encoding.enabled
是否开启http的编码支持，默认为true
spring.http.encoding.force
是否强制对http请求和响应进行编码，默认为true
spring.jackson.date-format
指定日期格式，比如yyyy-MM-dd HH:mm:ss，或者具体的格式化类的全限定名
spring.jackson.deserialization
是否开启Jackson的反序列化
spring.jackson.generator
是否开启json的generators.
spring.jackson.joda-date-time-format
指定Joda date/time的格式，比如yyyy-MM-dd HH:mm:ss). 如果没有配置的话，dateformat会作为backup
spring.jackson.locale
指定json使用的Locale.
spring.jackson.mapper
是否开启Jackson通用的特性.
spring.jackson.parser
是否开启jackson的parser特性.
spring.jackson.property-naming-strategy
指定PropertyNamingStrategy (CAMEL_CASE_TO_LOWER_CASE_WITH_UNDERSCORES)或者指定PropertyNamingStrategy子类的全限定类名.
spring.jackson.serialization
是否开启jackson的序列化.
spring.jackson.serialization-inclusion
指定序列化时属性的inclusion方式，具体查看JsonInclude.Include枚举.
spring.jackson.time-zone
指定日期格式化时区，比如America/Los_Angeles或者GMT+10.
spring.jersey.filter.order
指定Jersey filter的order，默认为: 0
spring.jersey.init
指定传递给Jersey的初始化参数.
spring.jersey.type
指定Jersey的集成类型，可以是servlet或者filter.

messages

mobile

view

resource

multipart

freemarker

velocity

thymeleaf

mustcache

groovy模板

http

json

jersey

reids

# REDIS (RedisProperties)

#spring.redis.database=0

spring.redis.host=127.0.0.1

spring.redis.password=

spring.redis.port=6379

spring.redis.pool.max-idle=100

spring.redis.pool.min-idle=1

spring.redis.pool.max-active=1000

spring.redis.pool.max-wait=-1

datasource

spring.datasource.name= # name of the data source

spring.datasource.initialize=true # populate using data.sql

spring.datasource.schema= # a schema (DDL) script resource reference

spring.datasource.data= # a data (DML) script resource reference

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

spring.datasource.continueOnError=false # continue even if can't be initialized

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

spring.datasource.driverClassName= # JDBC Settings...

spring.datasource.url=

spring.datasource.username=

spring.datasource.password=

spring.datasource.max-active=100 # Advanced configuration...

spring.datasource.max-idle=8

spring.datasource.min-idle=8

spring.datasource.initial-size=10

spring.datasource.validation-query=

spring.datasource.test-on-borrow=false

spring.datasource.test-on-return=false

spring.datasource.test-while-idle=

spring.datasource.time-between-eviction-runs-millis=

spring.datasource.min-evictable-idle-time-millis=

spring.datasource.max-wait-millis=

jpa

spring.jpa.database = MYSQL

# Show or not log for each sql query

spring.jpa.show-sql = true

# Hibernate ddl auto (create, create-drop, update)

spring.jpa.hibernate.ddl-auto = update

# Naming strategy

#[org.hibernate.cfg.ImprovedNamingStrategy #org.hibernate.cfg.DefaultNamingStrategy]

spring.jpa.hibernate.naming-strategy = org.hibernate.cfg.ImprovedNamingStrategy

DefaultNamingStrategy这个直接映射，不会做过多的处理（前提没有设置@Table，@Column等属性的时候）。

ImprovedNamingStrategy 表名，字段为小写，当有大写字母的时候会转换为分隔符号“_”。

# stripped before adding them to the entity manager)

spring.jpa.properties.hibernate.dialect= org.hibernate.dialect.MySQL5Dialect

tomcat

#server.tomcat.access-log-pattern= # log pattern of the access log

#server.tomcat.access-log-enabled=false # is access logging enabled

#server.tomcat.protocol-header=x-forwarded-proto # ssl forward headers

#server.tomcat.remote-ip-header=x-forwarded-for

#server.tomcat.basedir=/tmp # base dir (usually not needed, defaults totmp)

#server.tomcat.background-processor-delay=30; # in seconds

#server.tomcat.max-threads = 0 # number of threads in protocol handler

#server.tomcat.uri-encoding = UTF-8 # character encoding to use for URLdecoding

常用tomcat配置：

# tomcat最大线程数，默认为200

server.tomcat.max-threads=800

# tomcat的URI编码

server.tomcat.uri-encoding=UTF-8

# 存放Tomcat的日志、Dump等文件的临时文件夹，默认为系统的tmp文件夹（如：C:\Users\Angel\AppData\Local\Temp）

server.tomcat.basedir=D:/springboot-tomcat-tmp

# 打开Tomcat的Access日志，并可以设置日志格式的方法：

#server.tomcat.access-log-enabled=true

#server.tomcat.access-log-pattern=

# accesslog目录，默认在basedir/logs

#server.tomcat.accesslog.directory=

# 日志文件目录

logging.path=H:/springboot-tomcat-tmp

# 日志文件名称，默认为spring.log

logging.file=myapp.log

Server

#项目contextPath，一般在正式发布版本中，我们不配置

server.context-path=/springboot

# 错误页：指定发生错误时，跳转的URL。请查看BasicErrorController。

server.error.path=/error

# 服务端口，默认为8080

server.port=8080

# session最大超时时间(分钟)，默认为30

server.session-timeout=60

# 该服务绑定IP地址，启动服务器时如本机不是该IP地址则抛出异常启动失败，只有特殊需求的情况下才配置

# server.address=192.168.16.11

Aop

springboot默认的是Java的动态代理模式，我们只需要修改为CGLIB动态代码模式即可，只需要在application.properties加入如下配置：例如我们在service写接口，在实现类实现接口。（没有特殊用法不改）

spring.aop.proxy-target-class=true

MongoDb

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.

RebbitMQ

# RABBIT (RabbitProperties)

spring.rabbitmq.host= # connection host

spring.rabbitmq.port=# connection port

spring.rabbitmq.addresses= # connection addresses (e.g. myhost:9999,otherhost:1111)

spring.rabbitmq.username= # login user

spring.rabbitmq.password= # login password

spring.rabbitmq.virtualhost=

spring.rabbitmq.dynamic=

ActiveMq

# 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.

2：可以进行自定义配置类：

1：例如：Properties代码

wisely2.name=wyf2
wisely2.gender=male2

定义配置类：Java代码

@ConfigurationProperties(prefix = "wisely2")
public class Wisely2Settings {
private String name;
private String gender;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
10. }
11. public String getGender() {
12. return gender;
13. }
14. public void setGender(String gender) {
15. this.gender = gender;
16. }
17.

18. }

自定义配置文件名：

1：例如：Properties代码

wisely2.name=wyf2
wisely2.gender=male2

2：需定义如下配置类：Java代码

@ConfigurationProperties(prefix = "wisely",locations = "classpath:config/wisely.properties")
public class WiselySettings {
private String name;
private String gender;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
10. }
11. public String getGender() {
12. return gender;
13. }
14. public void setGender(String gender) {
15. this.gender = gender;
16. }
17.

18. }

最后在spring Boot入口类加上@EnableConfigurationProperties：Java代码

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

静态资源文件：

spring Boot 默认为我们提供了静态资源处理，使用WebMvcAutoConfiguration 中的配置各种属性。建议大家使用SpringBoot的默认配置方式，如果需要特殊处理的再通过配置进行修改。

如果想要自己完全控制WebMVC，就需要在@Configuration注解的配置类上增加@EnableWebMvc（@SpringBootApplication注解的程序入口类已经包含@Configuration），增加该注解以后WebMvcAutoConfiguration中配置就不会生效，你需要自己来配置需要的每一项。这种情况下的配置还是要多看一下WebMvcAutoConfiguration类。

控制台输出：

2016-01-08 09:29:30.437 INFO 24932 ---[ main]o.s.w.s.handler.SimpleUrlHandlerMapping : MappedURLpath[/**/favicon.ico]ont

默认路径：

其中默认配置的 /** 映射到 /static （或/public、/resources、/META-INF/resources）
其中默认配置的 /webjars/** 映射到 classpath:/META-INF/resources/webjars/
PS：上面的 static、public、resources 等目录都在 classpath: 下面（如 src/main/resources/static）。

自定义资源映射（工程目录下）：

以增加/myres/* 映射到 classpath:/myres/* 为例的代码处理为：

@Configuration

public class MyWebAppConfigurer extends WebMvcConfigurerAdapter {

@Override

public voidaddResourceHandlers(ResourceHandlerRegistry registry) {

registry.addResourceHandler("/myres/**").addResourceLocations("classpath:/myres/");

super.addResourceHandlers(registry);

}

使用外部目录

通过配置文件配置：

spring.mvc.static-path-pattern=

# 默认值为classpath:/META-INF/resources/,classpath:/resources/,classpath:/static/,classpath:/public/

spring.resources.static-locations=这里设置要指向的路径，多个使用英文逗号隔开，

使用spring.mvc.static-path-pattern 可以重新定义pattern，如修改为 /myres/** ，则访问static 等目录下的fengjing.jpg文件应该为http://localhost:8080/myres/fengjing.jpg ，修改之前为 http://localhost:8080/fengjing.jpg

使用 spring.resources.static-locations 可以重新定义 pattern 所指向的路径，支持 classpath: 和 file: （上面已经做过说明）

注意 spring.mvc.static-path-pattern 只可以定义一个，目前不支持多个逗号分割的方式。

定时任务：

@Configuration

@EnableScheduling

Public class SchedulingConfig {

@Scheduled(cron = "0/20 * * * * ?") // 每20秒执行一次

publicvoid scheduler() {

System.out.println(">>>>>>>>> SchedulingConfig.scheduler()");

}

Springboot启动select、Filter、Listener

在springBootApplication中加上@ServletComponentScan注解Servlet、Filter、Listener 可以直接通过 @WebServlet、@WebFilter、@WebListener 注解自动注册，无需其他代码。

例如：

@WebServlet(urlPatterns="/myServlet2/*",description="Servlet的说明")

public class MyServlet2 extends HttpServlet{

private static finallong serialVersionUID = 1L;

@Override

protected void doGet(HttpServletRequest req, HttpServletResponse resp) throwsServletException, IOException {

System.out.println(">>>>>>>>>>doGet()<<<<<<<<<<<");

doPost(req, resp);

}

@Override

protected void doPost(HttpServletRequest req, HttpServletResponse resp) throwsServletException, IOException {

System.out.println(">>>>>>>>>>doPost()<<<<<<<<<<<");

resp.setContentType("text/html");

PrintWriter out =resp.getWriter();

out.println("<html>");

out.println("<head>");

out.println("<title>Hello World</title>");

out.println("</head>");

out.println("<body>");

out.println("<h1>这是：myServlet2</h1>");

out.println("</body>");

out.println("</html>");

}

SpringBootApplication中：

@SpringBootApplication

@ServletComponentScan//这个就是扫描相应的Servlet包;

public class SpringBootSampleApplication {

public static void main(String[]args) {

SpringApplication.run(SpringBootSampleApplication.class, args);

}

SpringBoot拦截器：

1：实现HandlerInterceptor接口

Public class MyInterceptor1 implements HandlerInterceptor {

@Override

Public boolean preHandle(HttpServletRequestrequest, HttpServletResponse response, Object handler) throws Exception {

System.out.println(">>>MyInterceptor1>>>>>>>在请求处理之前进行调用（Controller方法调用之前）");

Return true;// 只有返回true才会继续向下执行，返回false取消当前请求

}

@Override

Public void postHandle(HttpServletRequestrequest, HttpServletResponse response, Object handler, ModelAndViewmodelAndView) throws Exception {

System.out.println(">>>MyInterceptor1>>>>>>>请求处理之后进行调用，但是在视图被渲染之前（Controller方法调用之后）");

}

@Override

Public void afterCompletion(HttpServletRequestrequest, HttpServletResponse response, Object handler, Exception ex)

throws Exception {

System.out.println(">>>MyInterceptor1>>>>>>>在整个请求结束之后被调用，也就是在DispatcherServlet 渲染了对应的视图之后执行（主要是用于进行资源清理工作）");

}

2：继承WebMvcConfigurerAdapter

@Configuration

public class MyWebAppConfigurer extends WebMvcConfigurerAdapter {

@Override

Public void addInterceptors(InterceptorRegistryregistry) {

// 多个拦截器组成一个拦截器链

// addPathPatterns 用于添加拦截规则

// excludePathPatterns 用户排除拦截

registry.addInterceptor(new MyInterceptor1()).addPathPatterns("/**");

registry.addInterceptor(new MyInterceptor2()).addPathPatterns("/**");

super.addInterceptors(registry);

}

启动时加载：

spring Boot 为我们提供了一个方法，通过实现接口 CommandLineRunner 来实现。

在多个启动加载时，可以用@Order(value=2)自定义执行顺序。

@Component

//@Order(value=2) 可以用这个注解来定义执行顺序

public class MyStartupRunner1 implements CommandLineRunner {

@Override

Public void run(String...args) throws Exception {

System.out.println(">>>>>>>>>>>>>>>服务启动执行，执行加载数据等操作<<<<<<<<<<<<<");

}

Springboot使用自定义properties

1：在application.properties中配置自定义配置属性时，想要注入自定义的配置类

application.properties中：

1. wisely2.name=wyf2

2. wisely2.gender=male2

自定义配置类：

@ConfigurationProperties(prefix = "wisely2")

2. public class Wisely2Settings {

3. private String name;

4. private String gender;

Get..set..

2：自定义配置文件名

wisely.properties：

1. wisely.name=wangyunfei

2. wisely.gender=male

需定义如下配置类：

@ConfigurationProperties(prefix = "wisely",locations = "classpath:config/wisely.properties")

2. public class WiselySettings {

3. private String name;

4. private String gender;

Get…set…

最后在Springboot 入口类加上@EnableConfigurationProperties

1. @SpringBootApplication

2. @EnableConfigurationProperties({WiselySettings.class,Wisely2Settings.class})

3. public class DemoApplication {

5. public static void main(String[] args) {

6. SpringApplication.run(DemoApplication.class, args);

7. }

8. }

Springboot自动扫描不同包

cn.kfit;包下的

@Configuration

public class MyCommandLineRunner2 implementsCommandLineRunner {

@Override

public void run(String... args) throws Exception {

System.out.println("MyCommandLineRunner2.run()");

}

cn.kfit;包下的：

@Configuration

public class MyCommandLineRunner1 implementsCommandLineRunner {

@Override

public void run(String... args) throws Exception {

System.out.println("MyCommandLineRunner1.run()");

}

@ComponentScan(basePackages={"cn.kfit","org.kfit"})

这时候你会发现，在App.java同包下的都没有被扫描了，所以如果也希望App.java包下的也同时被扫描的话，那么在进行指定包扫描的时候一定要进行指定配置：

@ComponentScan(basePackages={"cn.kfit","org.kfit","com.kfit"})

spring boot junit单元测试

1：加入maven依赖：

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

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

</dependency>

2：测试service

@Service

public class HelloService {

public String getName(){

return "hello";

}

3).编写测试类：

//// SpringJUnit支持，由此引入Spring-Test框架支持！

@RunWith(SpringJUnit4ClassRunner.class)

//// 指定我们SpringBoot工程的Application启动类

@SpringApplicationConfiguration(classes = App.class)

///由于是Web项目，Junit需要模拟ServletContext，因此我们需要给我们的测试类加上@WebAppConfiguration。

@WebAppConfiguration

public class HelloServiceTest {

@Resource

private HelloService helloService;

@Test

public void testGetName(){

Assert.assertEquals("hello",helloService.getName());

}

Junit注解介绍：

//在所有测试方法前执行一次，一般在其中写上整体初始化的代码
@BeforeClass

//在所有测试方法后执行一次，一般在其中写上销毁和释放资源的代码
@AfterClass

//在每个测试方法前执行，一般用来初始化方法（比如我们在测试别的方法时，类中与其他测试方法共享的值已经被改变，为了保证测试结果的有效性，我们会在@Before注解的方法中重置数据）
@Before

//在每个测试方法后执行，在方法执行完成后要做的事情
@After

// 测试方法执行超过1000毫秒后算超时，测试将失败
@Test(timeout = 1000)

// 测试方法期望得到的异常类，如果方法执行没有抛出指定的异常，则测试失败
@Test(expected = Exception.class)

// 执行测试时将忽略掉此方法，如果用于修饰类，则忽略整个类
@Ignore(“not ready yet”)
@Test

@RunWith
在JUnit中有很多个Runner，他们负责调用你的测试代码，每一个Runner都有各自的特殊功能，你要根据需要选择不同的Runner来运行你的测试代码。
如果我们只是简单的做普通Java测试，不涉及SpringWeb项目，你可以省略@RunWith注解，这样系统会自动使用默认Runner来运行你的代码。

文件上传：

1：在controller层中加入MultipartFile

@RequestMapping("/upload")
@ResponseBody
public String handleFileUpload(@RequestParam("file")MultipartFile file){
    if(!file.isEmpty()){
        try {
            BufferedOutputStream out = new BufferedOutputStream(new FileOutputStream(new File(file.getOriginalFilename())));
            out.write(file.getBytes());
            out.flush();
            out.close();
        }catch(FileNotFoundException e) {
            e.printStackTrace();
            return "上传失败,"+e.getMessage();
        }catch (IOException e) {
            e.printStackTrace();
            return "上传失败,"+e.getMessage();
        }
            return "上传成功";
    }else {
        return "上传失败，因为文件是空的.";
    }
}

2：在html中指定上传格式multipart/form-data

<html>
<head>
    <title>hello</title>
</head>
<body>
    <form action="/upload" method="post" enctype="multipart/form-data">
        <p>文件：<input type="file" name="file"/></p>
        <p><input type="submit" value="上传"/></p>
    </form>
</body>
</html>

3. 上传文件进行限制

@Bean
public MultipartConfigElement multipartConfigElement() {
MultipartConfigFactory factory = newMultipartConfigFactory();
//// 设置文件大小限制 ,超了，页面会抛出异常信息，这时候就需要进行异常信息的处理了;
factory.setMaxFileSize("128KB"); //KB,MB
/// 设置总上传数据总大小
factory.setMaxRequestSize("256KB");
//Sets the directory location wherefiles will be stored.
//factory.setLocation("路径地址");
return factory.createMultipartConfig();
}
/**
* 多文件具体上传时间，主要是使用了MultipartHttpServletRequest和MultipartFile
* @param request
* @return
*/
@RequestMapping(value="/batch/upload", method=RequestMethod.POST)
public @ResponseBody
String handleFileUpload(HttpServletRequest request){
List<MultipartFile> files =((MultipartHttpServletRequest)request).getFiles("file");
MultipartFile file = null;
BufferedOutputStream stream = null;
for (int i =0; i< files.size(); ++i) {
file = files.get(i);
if (!file.isEmpty()) {
try {
byte[] bytes = file.getBytes();
stream =
newBufferedOutputStream(new FileOutputStream(new File(file.getOriginalFilename())));
stream.write(bytes);
stream.close();
} catch (Exception e) {
stream = null;
return "You failed to upload " + i + " =>" + e.getMessage();
}
} else {
return "You failed to upload " + i + " becausethe file was empty.";
}
}
return "upload successful";
}

3. 多文件上传实现：

引用xml文件：

ImportResource有两种引用方式classpath和file

classpath路径：locations={"classpath:application-bean1.xml","classpath:application-bean2.xml"}

file路径：

locations= {"file:d:/test/application-bean1.xml"};

在Springboot入口同级目录下创建引用：

@Configuration
@ImportResource(locations = {"classpath:application-bean.xml"})
public class ConfigClass {

}

Xml文件：

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">

    
    <bean id="helloService" class="cn.bagtree.service.HelloService"/>
</beans>

Springboot 启动器：

Spring Boot应用启动器基本的一共有N（现知道的是44）种：具体如下：

1）spring-boot-starter这是Spring Boot的核心启动器，包含了自动配置、日志和YAML。

2）spring-boot-starter-actuator帮助监控和管理应用。

3）spring-boot-starter-amqp通过spring-rabbit来支持AMQP协议（Advanced Message Queuing Protocol）。

4）spring-boot-starter-aop支持面向方面的编程即AOP，包括spring-aop和AspectJ。

5）spring-boot-starter-artemis通过Apache Artemis支持JMS的API（Java Message Service API）。

6）spring-boot-starter-batc支持Spring Batch，包括HSQLDB数据库。

7）spring-boot-starter-cache支持Spring的Cache抽象。

8）spring-boot-starter-cloud-connectors支持Spring Cloud Connectors，简化了在像Cloud Foundry或Heroku这样的云平台上连接服务。

9）spring-boot-starter-data-elasticsearch支持ElasticSearch搜索和分析引擎，包括spring-data-elasticsearch。

10）spring-boot-starter-data-gemfire支持GemFire分布式数据存储，包spring-data-gemfire。

11）spring-boot-starter-data-jpa支持JPA（Java Persistence API），包括spring-data-jpa、spring-orm、Hibernate。

12）spring-boot-starter-data-mongodb支持MongoDB数据，包括spring-data-mongodb。

13）spring-boot-starter-data-rest通过spring-data-rest-webmvc，支持通过REST暴露Spring Data数据仓库。

14）spring-boot-starter-data-solr支持Apache Solr搜索平台，包括spring-data-solr。

15）spring-boot-starter-freemarker支持FreeMarker模板引擎。

16）spring-boot-starter-groovy-templates支持Groovy模板引擎。

17）spring-boot-starter-hateoas通过spring-hateoas支持基于HATEOAS的RESTful Web服务。

18）spring-boot-starter-hornetq通过HornetQ支持JMS。

19）spring-boot-starter-integration支持通用的spring-integration模块。

20）spring-boot-starter-jdbc支持JDBC数据库。

21）spring-boot-starter-jersey支持Jersey RESTful Web服务框架。

22）spring-boot-starter-jta-atomikos通过Atomikos支持JTA分布式事务处理。

23）spring-boot-starter-jta-bitronix通过Bitronix支持JTA分布式事务处理。

24）spring-boot-starter-mail支持javax.mail模块。

25）spring-boot-starter-mobile支持spring-mobile。

26）spring-boot-starter-mustache支持Mustache模板引擎。

27）spring-boot-starter-redis支持Redis键值存储数据库，包括spring-redis。

28）spring-boot-starter-security支持spring-security。

29）spring-boot-starter-social-facebook支持spring-social-facebook

30）spring-boot-starter-social-linkedin支持pring-social-linkedin

31）spring-boot-starter-social-twitter支持pring-social-twitter

32）spring-boot-starter-test支持常规的测试依赖，包括JUnit、Hamcrest、Mockito以及spring-test模块。

33）spring-boot-starter-thymeleaf支持Thymeleaf模板引擎，包括与Spring的集成。

34）spring-boot-starter-velocity支持Velocity模板引擎。

35）spring-boot-starter-web 支持全栈式Web开发，包括Tomcat和spring-webmvc。

36）spring-boot-starter-websocket支持WebSocket开发。

37）spring-boot-starter-ws支持Spring Web Services。Spring Boot应用启动器面向生产环境的还有2种，具体如下：

1）spring-boot-starter-actuator增加了面向产品上线相关的功能，比如测量和监控。

2）spring-boot-starter-remote-shell增加了远程ssh shell的支持。

最后，Spring Boot应用启动器还有一些替换技术的启动器，具体如下：

1）spring-boot-starter-jetty引入了Jetty HTTP引擎（用于替换Tomcat）。

2）spring-boot-starter-log4j支持Log4J日志框架。

3）spring-boot-starter-logging引入了Spring Boot默认的日志框架Logback。

4）spring-boot-starter-tomcat引入了Spring Boot默认的HTTP引擎Tomcat。

5）spring-boot-starter-undertow引入了Undertow HTTP引擎（用于替换Tomcat）。

SpringBoot集成redis

核心类：

@Configuration
@EnableCaching//启用缓存，这个注解很重要；
public class RedisCacheConfig extends CachingConfigurerSupport{
    /**
     * 缓存管理器.
     * @param redisTemplate
     * @return
     */
    @Bean
    public CacheManager cacheManager(RedisTemplate<?,?> redisTemplate) {
        CacheManager cacheManager = new RedisCacheManager(redisTemplate);
        return cacheManager;
    }

    /**
     * redis模板操作类,类似于jdbcTemplate的一个类;
     *
     * 虽然CacheManager也能获取到Cache对象，但是操作起来没有那么灵活；
     *
     * 这里在扩展下：RedisTemplate这个类不见得很好操作，我们可以在进行扩展一个我们
     *
     * 自己的缓存类，比如：RedisStorage类;
     *
     * @param factory : 通过Spring进行注入，参数在application.properties进行配置；
     * @return
     */
    @Bean
    public RedisTemplate<String, String> redisTemplate(RedisConnectionFactory factory) {
        RedisTemplate<String, String> redisTemplate = new RedisTemplate<String, String>();
        redisTemplate.setConnectionFactory(factory);

        //key序列化方式;（不然会出现乱码;）,但是如果方法上有Long等非String类型的话，会报类型转换错误；
        //所以在没有自己定义key生成策略的时候，以下这个代码建议不要这么写，可以不配置或者自己实现ObjectRedisSerializer
        //或者JdkSerializationRedisSerializer序列化方式;
//     RedisSerializer<String> redisSerializer = new StringRedisSerializer();//Long类型不可以会出现异常信息;
//     redisTemplate.setKeySerializer(redisSerializer);
//     redisTemplate.setHashKeySerializer(redisSerializer);

        return redisTemplate;
    }

/**
* 自定义key.
* 此方法将会根据类名+方法名+所有参数的值生成唯一的一个key,即使@Cacheable中的value属性一样，key也会不一样。
*/
@Override
public KeyGenerator keyGenerator() {
    System.out.println("RedisCacheConfig.keyGenerator()");
    return new KeyGenerator() {
        @Override
        public Object generate(Object o, Method method, Object... objects) {
            // This will generate a unique key of the class name, the method name
           //and all method parameters appended.
            StringBuilder sb = new StringBuilder();
            sb.append(o.getClass().getName());
            sb.append(method.getName());
            for (Object obj : objects) {
                sb.append(obj.toString());
            }
            System.out.println("keyGenerator=" + sb.toString());
            return sb.toString();
        }
    };
}

主要注解：@EnableCaching启用缓存

实现CachingConfigurer，然后注入需要的cacheManager和keyGenerator；从spring4开始默认的keyGenerator是SimpleKeyGenerator。不想要自定义key值可以不要keyGenerator

重写RedisTemplate模板，可以添加自己想要的数据

分布式Session状态保存redis

1.添加session依赖：

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

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

</dependency>

<groupId>org.springframework.session</groupId>

<artifactId>spring-session-data-redis</artifactId>

</dependency>

2.添加注解：@EnableRedisHttpSession

如果需要添加失效时间：@EnableRedisHttpSession(maxInactiveIntervalInSeconds = 60) //1分钟失效

3.所有实体类实现Serializable接口

Springboot日志记录slf4j

1、在 src/main/resources 下面创建logback.xml （根据不同环境来定义不同的日志输出，那么取名为logback-spring.xml 即可）文件，并按上面讲述的进行配置。
或者使用最简单的方法在 application 配置文件中配置。
2、在Java代码中创建实例，并在需要输出日志的地方使用。

logback-spring.xml 文件：

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

</springProfile>

</springProfile>

</configuration>

在代码中引用日志：

private Logger logger = LoggerFactory.getLogger(this.getClass());

也可以配置log4j-spring.properties 自定义格式：
在引入了log4j依赖之后，只需要在src/main/resources目录下加入log4j-spring.properties配置文件，就可以开始对应用的日志进行配置使用。

Springboot集成mytatis

1:在扫描入口加入主要注解：@MapperScan

@SpringBootApplication
@MapperScan("com.bagtree.mapper")
public class App {

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

2：写mapper层：

public interface DemoMapper {
    @Select("select *from Demo where name = #{name}")
    public List<Demo> likeName(String name);

    @Select("select *from Demo where id = #{id}")
    public Demo getById(long id);

    @Select("select name from Demo where id = #{id}")
    public String getNameById(long id);
}

分页插件的使用：

配置属性：

@Configuration

public class MyBatisConfiguration {

@Bean

public PageHelper pageHelper() {

System.out.println("MyBatisConfiguration.pageHelper()");

PageHelper pageHelper = new PageHelper();

Properties p = new Properties();

p.setProperty("offsetAsPageNum", "true");

p.setProperty("rowBoundsWithCount", "true");

p.setProperty("reasonable", "true");

pageHelper.setProperties(p);

return pageHelper;

}

查询时设置分页：PageHelper.startPage

@RequestMapping("/likeName")
public List<Demo> likeName(String name){
PageHelper.startPage(1,1);
return demoService.likeName(name);
}

Aop切面日志演示

实现AOP的切面主要有以下几个要素：

使用@Aspect注解将一个java类定义为切面类

使用@Pointcut定义一个切入点，可以是一个规则表达式，比如下例中某个package下的所有函数，也可以是一个注解等。

根据需要在切入点不同位置的切入内容

使用@Before在切入点开始处切入内容

使用@After在切入点结尾处切入内容

使用@AfterReturning在切入点return内容之后切入内容（可以用来对处理返回值做一些加工处理）

使用@Around在切入点前后切入内容，并自己控制何时执行切入点自身的内容

使用@AfterThrowing用来处理当切入内容部分抛出异常之后的处理逻辑

/**

* 实现Web层的日志切面

* @author Angel(QQ:412887952)

* @version v.0.1

@Aspect

@Component

@Order(-5)

public class WebLogAspect {

private Logger logger = LoggerFactory.getLogger(this.getClass());

ThreadLocal<Long> startTime = new ThreadLocal<Long>();

/**

* 定义一个切入点.

* 解释下：

* ~ 第一个 * 代表任意修饰符及任意返回值.

* ~ 第二个 * 任意包名

* ~ 第三个 * 代表任意方法.

* ~ 第四个 * 定义在web包或者子包

* ~ 第五个 * 任意方法

* ~ .. 匹配任意数量的参数.

@Pointcut("execution(public * com.kfit.*.web..*.*(..))")

Public void webLog(){}

@Before("webLog()")

Public void doBefore(JoinPoint joinPoint){

startTime.set(System.currentTimeMillis());

// 接收到请求，记录请求内容

logger.info("WebLogAspect.doBefore()");

ServletRequestAttributes attributes = (ServletRequestAttributes) RequestContextHolder.getRequestAttributes();

HttpServletRequest request = attributes.getRequest();

// 记录下请求内容

logger.info("URL : " + request.getRequestURL().toString());

logger.info("HTTP_METHOD : " + request.getMethod());

logger.info("IP : " + request.getRemoteAddr());

logger.info("CLASS_METHOD : " + joinPoint.getSignature().getDeclaringTypeName() +"." + joinPoint.getSignature().getName());

logger.info("ARGS : " + Arrays.toString(joinPoint.getArgs()));

//获取所有参数方法一：

Enumeration<String> enu=request.getParameterNames();

while(enu.hasMoreElements()){

String paraName=(String)enu.nextElement();

System.out.println(paraName+": "+request.getParameter(paraName));

}

@AfterReturning("webLog()")

Public void doAfterReturning(JoinPoint joinPoint){

// 处理完请求，返回内容

logger.info("WebLogAspect.doAfterReturning()");

logger.info("耗时（毫秒） : " + (System.currentTimeMillis() - startTime.get()));

}

Springboot部署配置：

更改jetty为启动服务器：

1：spring boot默认是Tomcat，如果你要选择Jetty,也非常简单，只需要把pom.xml中的tomcat依赖排除，并加入Jetty容器的依赖接口，如下配置：

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

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

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

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

</exclusion>

</exclusions>

</dependency>

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

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

</dependency>

2：修改启动类，继承 SpringBootServletInitializer 并重写 configure 方法

@SpringBootApplication

publicclass App extends SpringBootServletInitializer{

@Override

protected SpringApplicationBuilder configure(SpringApplicationBuilder builder) {

returnbuilder.sources(this.getClass());

}

Public static void main(String[] args) {

SpringApplication.run(App.class, args);

}

3：修改pom文件中jar 为 war

打印springboot启动时加载的bean

我们只需要稍微调整下就可以获取到ApplicationContext上下文了，在这个类中就可以有很多的方法进行操作了，修改为如下：

ApplicationContext ctx = SpringApplication.run(ApiCoreApp.class, args);

第一种情况获取所有的beans:

ApplicationContext ctx = SpringApplication.run(ApiCoreApp.class, args);

String[] beanNames = ctx.getBeanDefinitionNames();

System.out.println("所以beanNames个数："+beanNames.length);

for(String bn:beanNames){

System.out.println(bn);

}

Springboot访问url路径规则

核心的开发步骤就是两步：

（1）启动类 extends WebMvcConfigurationSupport

（2）重写configurePathMatch方法；

@SpringBootApplication

public class ApiCoreApp extends WebMvcConfigurationSupport{

/**

* 1、 extends WebMvcConfigurationSupport

* 2、重写下面方法;

* setUseSuffixPatternMatch : 设置是否是后缀模式匹配，如“/user”是否匹配/user.*，默认真即匹配；

* setUseTrailingSlashMatch : 设置是否自动后缀路径模式匹配，如“/user”是否匹配“/user/”，默认真即匹配；

@Override

Public void configurePathMatch(PathMatchConfigurer configurer) {

configurer.setUseSuffixPatternMatch(false)

.setUseTrailingSlashMatch(true);

}

Public static void main(String[] args) {

SpringApplication.run(ApiCoreApp.class, args);

}

Springboot集成MongoDB

/**

* 继承自MongoRepository接口，MongoRepository接口包含了常用的CRUD操作，

* 例如：save、insert、findall等等。我们可以定义自己的查找接口，

* 例如根据demoInfo的name搜索，具体的DemoInfoRepository接口代码如下：

* @author Angel --守护天使

* @version v.0.1

* @date 2016年8月18日下午3:15:49

public interface DemoInfoRepository extends MongoRepository<DemoInfo, String> {

DemoInfo findByName(String name);

}

Springboot集成RebbitMQ

@SpringBootApplication

@EnableScheduling//启用任务调度.

@RabbitListener(queues="foo")//启用Rabbit队列监听foo key.作用于类下所有方法

public class App {

//rabbit操作类;

@Autowired

private RabbitTemplate rabbitTemplate;

@Scheduled(fixedDelay=3000)//3s执行1次此方法;

public void send(){

rabbitTemplate.convertAndSend("foo","zhang");

}

@Bean

public Queue fooQueue(){

returnnew Queue("foo");

}

//接收到消息处理.

@RabbitHandler

public void onMessage(@Payload String foo){

System.out.println(" >>> "+new Date() + ": " + foo);

}

public static void main(String[] args) {

SpringApplication.run(App.class, args);

}

方法还可以在简化下，将类上的@RabbitListener直接转移到方法上，去掉@RabbitHandler注解，直接为如下：

//接收到消息处理.

@RabbitListener(queues = "foo")

public void onMessage(@Payload String foo){

System.out.println(" >new>> "+new Date() + ": " + foo);

}

Springboot集成ActiveMQ

1.启动入口：

@SpringBootApplication

public class App {

@Bean

public Queue queue() {

return new ActiveMQQueue("sample.queue");

}

public static void main(String[] args) {

SpringApplication.run(App.class, args);

}

2.消费者

@Component

@EnableScheduling

public class Producer {

@Autowired

private JmsMessagingTemplate jmsMessagingTemplate;

@Autowired

private Queue queue;

@Scheduled(fixedDelay=3000)//每3s执行1次

public void send() {

this.jmsMessagingTemplate.convertAndSend(this.queue, "hi,activeMQ");

}

3.监听者

@Component

public class Consumer {

@JmsListener(destination = "sample.queue")

public void receiveQueue(String text) {

System.out.println(text);

}

posted on 2017-02-16 18:18 阿发仔阅读(893) 评论(0) 编辑收藏举报

刷新页面返回顶部