SpringBoot

Spring boot

1.springboot引言

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

springboot=spring+springmvc

2.springboot的特点

• 创建独立的spring应用
• 内嵌了一个tomcat,无需war包部署
• 摒弃xml形式的开发
• 简化maven配置
• 以jar包形式运行
• 自动配置spring (原理)
  

3.springboot的约束

src/main/java
   com.baizhi 主包
             entity 子包
             dao
             service
             controller
             util
             入口类(main)     存放位置:必须存放在当前主包下和子包平级
src/test/java
src/main/resources
      配置文件: application  三种配置形式
                                       application.yml
                                       application.yaml
                                       application.properties
src/test/resources

4.springboot的环境搭建

1.基于maven的形式构建springboot应用

1.导入依赖

 <!--父级项目依赖-->
  <parent>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-parent</artifactId>
    <version>1.5.8.RELEASE</version>
  </parent>
<!--web启动器-->
  <dependency>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-starter-web</artifactId>
  </dependency>

2.创建入口类

//表示当前项目为springboot应用 
@SpringBootApplication
public class App {
    public static void main(String[] args) {
//      参数1 当前入口类的类对象  参数2 main函数的参数
        SpringApplication.run(App.class,args);
    }
}

3.构建配置文件

server:  层级之间有一个tab键的间隔
  port: 8989
  属性名和值之间有一个空格的间隔
  context-path: /springboot

默认配置文件没有内容
默认springboot端口号为8080
默认没有项目名

默认不支持jsp为视图层模板,[Thymeleaf]

4.测试

@Controller
@RequestMapping("user")
public class UserController {
    @ResponseBody
    @RequestMapping("test")
    public String test() {
        return "hello world";
    }
}

---

2.基于Spring Initializr构建springboot应用

1.选择Spring Initializr

2.填写必要参数

3.勾选场景启动器

5.springboot的相关注解

1.SpringbootApplication 组合注解

由以下的三个注解组成
@Configuration  加在某个类上表示当前类为配置类等同于spring的配置文件
@ComponentScan  组件扫描  类上标明有 @Repository 称为spring的组件
                                  @Component
                                  @Service
                                  @Controller
                                  spring提供注解扫描机制将含有以上四种注解的类交由工厂管理

@EnableAutoConfiguration    支持自动配置.   

2.java配置

@Configuration
//注解包扫描机制  可以自定义排除 和 只包含如果想让只包含生效则需关闭默认扫描策略useDefaultFilters = false
@ComponentScan(basePackages = "com.baizhi.*",
        includeFilters =
                {@ComponentScan.Filter(type = FilterType.ANNOTATION,classes = Controller.class)},useDefaultFilters = false)
public class PersonConf {
    @Bean
    //返回值 表示交由工厂管理的对象 
    // 方法名 容器中对象的名字
    public Person getPerson(){
        Person person = new Person();
        person.setName("hehe");
        person.setPassword("23456");
        return person;
    }
}
    //从工厂种获取相应的bean
   //获取容器  参数 配之类的类对象
   AnnotationConfigApplicationContext  annotationConfigApplicationContext=new AnnotationConfigApplicationContext(PersonConf.class);
//获取容器种的相应组件     参数  bean的名字或者类型
Person getPerson = 
           (Person)annotationConfigApplicationContext.getBean(Person.class);
        System.out.println(getPerson);

6.springboot和第三方技术的集成

1.springboot集成mybatis

1.引入相关依赖

  <dependency>
      <groupId>mysql</groupId>
      <artifactId>mysql-connector-java</artifactId>
      <version>5.1.38</version>
    </dependency>
    
   <dependency>
      <groupId>com.alibaba</groupId>
      <artifactId>druid</artifactId>
      <version>1.0.31</version>
    </dependency>
 <!--整合mybatis启动器-->
    <dependency>
      <groupId>org.mybatis.spring.boot</groupId>
      <artifactId>mybatis-spring-boot-starter</artifactId>
      <version>1.3.3</version>
    </dependency>

2.配置文件

server:
  port: 8989
  context-path: /springboot
spring:
  datasource:
    type: com.alibaba.druid.pool.DruidDataSource
    username: root
    password: root
    url: jdbc:mysql://localhost:3306/springboot
    driver-class-name: com.mysql.jdbc.Driver
mybatis:
  type-aliases-package: com.baizhi.entity  #指定别名包
  mapper-locations: com/baizhi/dao/*Mapper.xml #指定mapper文件的位置

3.在入口类添加dao包的扫描注解@MapperScan

//表示当前项目为springboot应用
@SpringBootApplication
//指定dao包的位置
@MapperScan(basePackages = "com.baizhi.dao")
public class App {
    public static void main(String[] args) {
//      参数1 当前入口类的类对象  参数2 main函数的参数
        SpringApplication.run(App.class,args);
    }
}

2.springboot集成jsp

1.导入jsp解析支持的相关jar

在这里插入图片描述

 <!--使内嵌的tomcat支持解析jsp-->
    <dependency>
      <groupId>org.apache.tomcat.embed</groupId>
      <artifactId>tomcat-embed-jasper</artifactId>
    </dependency>

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

    <!--引入jsp的支持-->
    <dependency>
      <groupId>jstl</groupId>
      <artifactId>jstl</artifactId>
      <version>1.2</version>
    </dependency>

2.配置视图解析器

#添加视图解析器
spring:
  mvc:
    view:
      prefix: /
      suffix: .jsp

3.通过插件形式启动

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

4.配置页面的热部署

#提供页面热部署
server:
  jsp-servlet:
    init-parameters:
      development: true

3.lombok

lombok的作用简化代码,使代码更加优雅,以字节码的形式生成get set …

1.安装插件

2.导入依赖

  <dependency>
      <groupId>org.projectlombok</groupId>
      <artifactId>lombok</artifactId>
      <version>1.18.8</version>
      <scope>provided</scope>
    </dependency>

3.了解相关注解

@Getter   get方法
@Setter   set方法
@Accessors(chain = true)  链式调用
@ToString        tostring方法
@EqualsAndHashCode    EqualsAndHashCode方法
@NoArgsConstructor    无参构造
@Data        包含上述注解     

@AllArgsConstructor 全参构造

4.logback

1.日志的级别

低                                        高

debug <info<  warning<  error

级别越低:日志打印量越多,粒度越细

级别越高:日志打印量越少,粒度越粗

2.日志的分类

父日志 : root(根日志),针对整个项目的日志   控制程序员自己写的日志 和框架里面的日志 

子日志:logger,针对某个包的日志 ,子日志优先级高于父日志.

3.输出目的地Appender

org.apache.log4j.ConsoleAppender(控制台),

org.apache.log4j.FileAppender（文件）,

org.apache.log4j.DailyRollingFileAppender（每天产生一个日志文件），

org.apache.log4j.RollingFileAppender（文件大小到达指定尺寸的时候产生一个新的文件），

org.apache.log4j.WriterAppender（将日志信息以流格式发送到任意指定的地方） 

4.Layout：日志输出格式，Log4j提供的layout有以下几种：

org.apache.log4j.HTMLLayout（以HTML表格形式布局）， 

org.apache.log4j.PatternLayout（可以灵活地指定布局模式）

org.apache.log4j.SimpleLayout（包含日志信息的级别和信息字符串），

org.apache.log4j.TTCCLayout（包含日志产生的时间、线程、类别等等信息） 

5.日志相关的参数

   %m   输出代码中指定的消息
　　%p   输出优先级，即DEBUG，INFO，WARN，ERROR，FATAL 
　　%r   输出自应用启动到输出该log信息耗费的毫秒数 
　　%c   输出所属的类目，通常就是所在类的全名 
　　%t   输出产生该日志事件的线程名 
　　%n   输出一个回车换行符，Windows平台为“/r/n”，Unix平台为“/n” 
　　%d   输出日志时间点的日期或时间，默认格式为ISO8601，也可以在其后指定格式，比如：%d{yyy MMM dd HH:mm:ss , SSS}，输出类似：2002年10月18日  22 ： 10 ： 28 ， 921  
　　%l   输出日志事件的发生位置，包括类目名、发生的线程，以及在代码中的行数。举例：Testlog4.main(TestLog4.java: 10 ) 

6.logback的两种形式

1.logback的配置文件,在springboot中引入该配置文件 命名为logback.xml

注意:yml配置日志格式和xml配置日志格式 不能混用 任选其一

注意:springboot默认集成logback的jar包所以不需要引入依赖

注意:springboot默认logback的配置文件路径为:org/springframework/boot/logging/logback/base.xml

<?xml version="1.0" encoding="UTF-8" ?>
<configuration>
    <appender name="stdout" class="ch.qos.logback.core.ConsoleAppender">
        <layout class="ch.qos.logback.classic.PatternLayout">
            <pattern> [%p] [%d{yyyy-MM-dd HH:mm:ss}] %m %n</pattern>
        </layout>
    </appender>
    <root level="info">
        <appender-ref ref="stdout"/>
    </root>
    <logger name="com.baizhi.mapper" level="DEBUG"/>
</configuration>

2.使用springboot的自动配置控制日志

logging.level.root=debug  #设置父日志级别
logging.level.com.baizhi.conf=debug  #设置指定包的日志级别
logging.file= 文件名|路径 建议使用 / 代表项目所在磁盘的根目录 此配置使logging.path失效
logging.path=路径+文件名
logging.pattern.console= [%p] [%d{yyyy-MM-dd HH:mm:ss}] %c %m %n  控制台的日志格式(yml需加单引号),
logging.pattern.file= 同上  文件的日志格式

8.在编码中使用logback写日志

//写日志的两种方式
   //在类中声明 logger对象
    Logger log=LoggerFactory.getLogger(TestDao.class);
   //配合lombok使用
    只需要在类上加@Slf4j注解
            //这里的{}  指的占位符 表示 后边需要打印的对象类型或者是基本类型  打印多个值则需要多个占位符
            log.info("this is info{}", user);
            log.debug("this is debug{}", user);
            log.warn("this is warn{}", user);
            log.error("this is error{}", user);

7.自动配置原理

1.属性注入

1.spring中属性注入

声明配置文件
jdbc.password=root
jdbc.url=jdbc:mysql://localhost:3306/springboot
jdbc.driver-class-name=com.mysql.jdbc.Driver
jdbc.username=root

完成属性注入
@Configuration
//从配置文件获取值
@PropertySource(value = "jdbc.properties")
public class CreateDatasource {
    /*
    * 属性注入
    * */
    @Value("${jdbc.username}")
    private String username;
    @Value("${jdbc.url}")
    private String url;
    @Value("${jdbc.driver-class-name}")
    private String driver;
    @Value("${jdbc.password}")
    private String password;

  @Bean
  public DruidDataSource getDruidDataSource(){
      DruidDataSource druidDataSource = new DruidDataSource();
      druidDataSource.setDriverClassName(driver);
      druidDataSource.setUrl(url);
      druidDataSource.setUsername(username);
      druidDataSource.setPassword(password);
      return druidDataSource;
  }
  
}

2.springboot中的属性注入

1.配置文件中声明相关属性

application.yml
server.port=8989
server.context-path=/springboot
jdbc.password=root
jdbc.url=jdbc:mysql://localhost:3306/springboot
jdbc.driver=com.mysql.jdbc.Driver
jdbc.username=root

2.创建属性配置类并对属性进行注入

@ConfigurationProperties(prefix = "jdbc")  //读取application.yml的属性,并且为当前属性类添加前缀 
public class JDBCProperties {
    private String username;
    private String password;
    private String url;
    private String driver;
}

3.创建配置类引入属性配置类

@EnableConfigurationProperties(value = JDBCProperties.class)//获取配置文件类 
@Configuration
public class JDBCConf {
    @Autowired
    JDBCProperties jdbcProperties;

     @Bean
    public DruidDataSource getDruidDataSource(){
        DruidDataSource druidDataSource = new DruidDataSource();
        druidDataSource.setPassword(jdbcProperties.getPassword());
        druidDataSource.setUsername(jdbcProperties.getUsername());
        druidDataSource.setUrl(jdbcProperties.getUrl());
        druidDataSource.setDriverClassName(jdbcProperties.getDriver());
        return druidDataSource;
    }
}

4.配置文件提示的jar

  <!--此jar包可以让配置文件有提示-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-configuration-processor</artifactId>
            <optional>true</optional>
        </dependency>

2.@Import

将组件交由工厂管理方式有几种?
java配置   @Confirguation @Bean
注解扫描    @ComponentScan  扫描加有@Repository @Component @Service @Controller的组件
@Import    也可以将组件交由工厂管理   注意:使用@Import注解交由工厂管理的对象名称为全限定名.
           第一种使用方式  @Import(value = {Black.class,Pink.class})
           第二种使用方式  实现ImportSelector接口和其中方法                        

实现ImportSelector接口和其中方法

@Override
    public String[] selectImports(AnnotationMetadata importingClassMetadata) {
//       逻辑代码
        String[] strs={"com.baizhi.conf.Blue","com.baizhi.conf.Red"};
        return strs;
    }

3.自动配置原理

1.EnableAutoConfiguration

@EnableAutoConfiguration= 
@AutoConfigurationPackage +@Import(EnableAutoConfigurationImportSelector.class) 注解
                 @AutoConfigurationPackage  
                 作用就是帮你找到入口类
                 @Import(EnableAutoConfigurationImportSelector.class)
                 public @interface EnableAutoConfiguration {
                     
                 }
                 
                 @Import(EnableAutoConfigurationImportSelector.class)  
                 作用就是往容器种添加组件,添加一个全限定名数组.
                 

通过selectImports()方法获取到类的全限定名,以数组形式返回,然后加入到spring的容器中.

加载类路径下的META-info/spring.factorys从而获取到相关的自动配置类信息

以org.springframework.boot.autoconfigure.EnableAutoConfiguration为键进行取值

自动配置类是springboot默认提供的自动配置.

org.springframework.boot.autoconfigure.EnableAutoConfiguration=\
org.springframework.boot.autoconfigure.admin.SpringApplicationAdminJmxAutoConfiguration,\
org.springframework.boot.autoconfigure.aop.AopAutoConfiguration,\
org.springframework.boot.autoconfigure.amqp.RabbitAutoConfiguration,\
org.springframework.boot.autoconfigure.batch.BatchAutoConfiguration,\
org.springframework.boot.autoconfigure.cache.CacheAutoConfiguration,\
org.springframework.boot.autoconfigure.cassandra.CassandraAutoConfiguration,\
org.springframework.boot.autoconfigure.cloud.CloudAutoConfiguration,\
org.springframework.boot.autoconfigure.context.ConfigurationPropertiesAutoConfiguration,\
org.springframework.boot.autoconfigure.context.MessageSourceAutoConfiguration,\
org.springframework.boot.autoconfigure.context.PropertyPlaceholderAutoConfiguration,\
org.springframework.boot.autoconfigure.couchbase.CouchbaseAutoConfiguration,\
org.springframework.boot.autoconfigure.dao.PersistenceExceptionTranslationAutoConfiguration,\
org.springframework.boot.autoconfigure.data.cassandra.CassandraDataAutoConfiguration,\
org.springframework.boot.autoconfigure.data.cassandra.CassandraRepositoriesAutoConfiguration,\
org.springframework.boot.autoconfigure.data.couchbase.CouchbaseDataAutoConfiguration,\
org.springframework.boot.autoconfigure.data.couchbase.CouchbaseRepositoriesAutoConfiguration,\
org.springframework.boot.autoconfigure.data.elasticsearch.ElasticsearchAutoConfiguration,\
org.springframework.boot.autoconfigure.data.elasticsearch.ElasticsearchDataAutoConfiguration,\
org.springframework.boot.autoconfigure.data.elasticsearch.ElasticsearchRepositoriesAutoConfiguration,\
org.springframework.boot.autoconfigure.data.jpa.JpaRepositoriesAutoConfiguration,\
org.springframework.boot.autoconfigure.data.ldap.LdapDataAutoConfiguration,\
org.springframework.boot.autoconfigure.data.ldap.LdapRepositoriesAutoConfiguration,\
org.springframework.boot.autoconfigure.data.mongo.MongoDataAutoConfiguration,\
org.springframework.boot.autoconfigure.data.mongo.MongoRepositoriesAutoConfiguration,\
org.springframework.boot.autoconfigure.data.neo4j.Neo4jDataAutoConfiguration,\
org.springframework.boot.autoconfigure.data.neo4j.Neo4jRepositoriesAutoConfiguration,\
org.springframework.boot.autoconfigure.data.solr.SolrRepositoriesAutoConfiguration,\
org.springframework.boot.autoconfigure.data.redis.RedisAutoConfiguration,\
org.springframework.boot.autoconfigure.data.redis.RedisRepositoriesAutoConfiguration,\
org.springframework.boot.autoconfigure.data.rest.RepositoryRestMvcAutoConfiguration,\
org.springframework.boot.autoconfigure.data.web.SpringDataWebAutoConfiguration,\
org.springframework.boot.autoconfigure.elasticsearch.jest.JestAutoConfiguration,\
org.springframework.boot.autoconfigure.freemarker.FreeMarkerAutoConfiguration,\
org.springframework.boot.autoconfigure.gson.GsonAutoConfiguration,\
org.springframework.boot.autoconfigure.h2.H2ConsoleAutoConfiguration,\
org.springframework.boot.autoconfigure.hateoas.HypermediaAutoConfiguration,\
org.springframework.boot.autoconfigure.hazelcast.HazelcastAutoConfiguration,\
org.springframework.boot.autoconfigure.hazelcast.HazelcastJpaDependencyAutoConfiguration,\
org.springframework.boot.autoconfigure.info.ProjectInfoAutoConfiguration,\
org.springframework.boot.autoconfigure.integration.IntegrationAutoConfiguration,\
org.springframework.boot.autoconfigure.jackson.JacksonAutoConfiguration,\
org.springframework.boot.autoconfigure.jdbc.DataSourceAutoConfiguration,\
org.springframework.boot.autoconfigure.jdbc.JdbcTemplateAutoConfiguration,\
org.springframework.boot.autoconfigure.jdbc.JndiDataSourceAutoConfiguration,\
org.springframework.boot.autoconfigure.jdbc.XADataSourceAutoConfiguration,\
org.springframework.boot.autoconfigure.jdbc.DataSourceTransactionManagerAutoConfiguration,\
org.springframework.boot.autoconfigure.jms.JmsAutoConfiguration,\
org.springframework.boot.autoconfigure.jmx.JmxAutoConfiguration,\
org.springframework.boot.autoconfigure.jms.JndiConnectionFactoryAutoConfiguration,\
org.springframework.boot.autoconfigure.jms.activemq.ActiveMQAutoConfiguration,\
org.springframework.boot.autoconfigure.jms.artemis.ArtemisAutoConfiguration,\
org.springframework.boot.autoconfigure.flyway.FlywayAutoConfiguration,\
org.springframework.boot.autoconfigure.groovy.template.GroovyTemplateAutoConfiguration,\
org.springframework.boot.autoconfigure.jersey.JerseyAutoConfiguration,\
org.springframework.boot.autoconfigure.jooq.JooqAutoConfiguration,\
org.springframework.boot.autoconfigure.kafka.KafkaAutoConfiguration,\
org.springframework.boot.autoconfigure.ldap.embedded.EmbeddedLdapAutoConfiguration,\
org.springframework.boot.autoconfigure.ldap.LdapAutoConfiguration,\
org.springframework.boot.autoconfigure.liquibase.LiquibaseAutoConfiguration,\
org.springframework.boot.autoconfigure.mail.MailSenderAutoConfiguration,\
org.springframework.boot.autoconfigure.mail.MailSenderValidatorAutoConfiguration,\
org.springframework.boot.autoconfigure.mobile.DeviceResolverAutoConfiguration,\
org.springframework.boot.autoconfigure.mobile.DeviceDelegatingViewResolverAutoConfiguration,\
org.springframework.boot.autoconfigure.mobile.SitePreferenceAutoConfiguration,\
org.springframework.boot.autoconfigure.mongo.embedded.EmbeddedMongoAutoConfiguration,\
org.springframework.boot.autoconfigure.mongo.MongoAutoConfiguration,\
org.springframework.boot.autoconfigure.mustache.MustacheAutoConfiguration,\
org.springframework.boot.autoconfigure.orm.jpa.HibernateJpaAutoConfiguration,\
org.springframework.boot.autoconfigure.reactor.ReactorAutoConfiguration,\
org.springframework.boot.autoconfigure.security.SecurityAutoConfiguration,\
org.springframework.boot.autoconfigure.security.SecurityFilterAutoConfiguration,\
org.springframework.boot.autoconfigure.security.FallbackWebSecurityAutoConfiguration,\
org.springframework.boot.autoconfigure.security.oauth2.OAuth2AutoConfiguration,\
org.springframework.boot.autoconfigure.sendgrid.SendGridAutoConfiguration,\
org.springframework.boot.autoconfigure.session.SessionAutoConfiguration,\
org.springframework.boot.autoconfigure.social.SocialWebAutoConfiguration,\
org.springframework.boot.autoconfigure.social.FacebookAutoConfiguration,\
org.springframework.boot.autoconfigure.social.LinkedInAutoConfiguration,\
org.springframework.boot.autoconfigure.social.TwitterAutoConfiguration,\
org.springframework.boot.autoconfigure.solr.SolrAutoConfiguration,\
org.springframework.boot.autoconfigure.thymeleaf.ThymeleafAutoConfiguration,\
org.springframework.boot.autoconfigure.transaction.TransactionAutoConfiguration,\
org.springframework.boot.autoconfigure.transaction.jta.JtaAutoConfiguration,\
org.springframework.boot.autoconfigure.validation.ValidationAutoConfiguration,\
org.springframework.boot.autoconfigure.web.DispatcherServletAutoConfiguration,\
org.springframework.boot.autoconfigure.web.EmbeddedServletContainerAutoConfiguration,\
org.springframework.boot.autoconfigure.web.ErrorMvcAutoConfiguration,\
org.springframework.boot.autoconfigure.web.HttpEncodingAutoConfiguration,\
org.springframework.boot.autoconfigure.web.HttpMessageConvertersAutoConfiguration,\
org.springframework.boot.autoconfigure.web.MultipartAutoConfiguration,\
org.springframework.boot.autoconfigure.web.ServerPropertiesAutoConfiguration,\
org.springframework.boot.autoconfigure.web.WebClientAutoConfiguration,\
org.springframework.boot.autoconfigure.web.WebMvcAutoConfiguration,\
org.springframework.boot.autoconfigure.websocket.WebSocketAutoConfiguration,\
org.springframework.boot.autoconfigure.websocket.WebSocketMessagingAutoConfiguration,\
org.springframework.boot.autoconfigure.webservices.WebServicesAutoConfiguration

以WebMvcAutoConfiguration为例在该类中已经预先配置了相关的一些组件,比如视图解析器,但是默认的视图解析器没有属性值,如果想设置属性值则需通过配置文件进行属性注入方可完成自动配置

属性配置类一般一properties结尾,每一个自动配置类都会有一个对应的properties

4.启动器

spring-boot-starter-web
spring-boot-starter(启动器)     -web应用场景
springboot提供的启动器列表
https://docs.spring.io/spring-boot/docs/1.5.22.BUILD-SNAPSHOT/reference/html/using-boot-build-systems.html#using-boot-starter
默认没有为mybatis提供启动器,所以mybatis自己定义了一套启动器.

1.自定义启动器

1.构建java项目
2.引入父级项目.启动器规范的依赖.配置文件提示依赖
  <parent>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starters</artifactId>
    <version>1.5.8.RELEASE</version>
  </parent>
   <dependency>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-starter</artifactId>
    </dependency>

    <dependency>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-configuration-processor</artifactId>
      <optional>true</optional>
    </dependency>
3.resources下构建META-INF目录
4.在META-INF目录下创建spring.factories,并且将EnableAutoConfirguration设置为键值,将自动配置类设置为值.
org.springframework.boot.autoconfigure.EnableAutoConfiguration=\
  com.baizhi.autoconfirguation.HelloConf
5.将项目install到maven的本地仓库
6.在springboot项目中引用当前自动配置的依赖jar
7.书写配置文件测试自动配置

8.springboot中的细节

1.springboot中的测试

1.引入测试依赖

<!--测试的启动器 可以帮助你快速的完成测试 并且这个启动器中封装了junit-->
    <dependency>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-starter-test</artifactId>
    </dependency>

2.构建测试类

@SpringBootTest(classes = App.class)  //声明当前类为springboot的测试类 并且指定入口类
@RunWith(value = SpringRunner.class)     // 在容器环境下启动测试
public class TestDao {
    @Autowired
    UserDao userDao;
    @Test
    public void testUserDao() {
        List<User> users = userDao.queryAll();
        for (User user : users) {
            System.out.println(user);
        }
    }
}

2.springboot中的配置文件切分

创建三个配置文件 application为主配置文件,两个小配置文件分别为application-xxx.yml,如果在主配文件中想切换小配置文件采用以下配置

spring:
  profiles:
    active: product

3.springboot中的编码过滤器

web包中自动配置类HttpEncodingAutoConfiguration

@Bean
	@ConditionalOnMissingBean(CharacterEncodingFilter.class)
	public CharacterEncodingFilter characterEncodingFilter() {
		CharacterEncodingFilter filter = new OrderedCharacterEncodingFilter();
		filter.setEncoding(this.properties.getCharset().name());
		filter.setForceRequestEncoding(this.properties.shouldForce(Type.REQUEST));
		filter.setForceResponseEncoding(this.properties.shouldForce(Type.RESPONSE));
		return filter;
	}

配置文件中配置编码形式

spring:
  http:
    encoding:
      charset: utf-8
      force: true   #强制使用utf-8
      force-request: true #强制请求使用utf-8
      force-response: true #强制响应使用utf-8

4.springboot中的热部署

1.导入相关依赖

 <!--热部署依赖-->
    <dependency>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-devtools</artifactId>
      <version>1.5.8.RELEASE</version>
    </dependency>
注意:只支持jsp的热部署,如果想实现后台代码的热部署,需要进行ide(java的集成开发环境)的进行配置

2.开启idea的自动编译

3.开启运行自动编译

5.springboot中的jar包部署 java -jar jar包

springboot的jar包的目录结构

将springboot中的jsp加入到META-INF

<plugins>
      <plugin>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-maven-plugin</artifactId>
        <version>1.4.2.RELEASE</version>
       <!--打jar包注意事项1-->
        <configuration>
          <mainClass>com.baizhi.App</mainClass>
          <layout>JAR</layout>
        </configuration>
    </plugin>
    </plugins>
    <resources>
      <!-- 打包时将jsp文件拷贝到META-INF目录下-->
      <resource>
        <!-- 指定resources插件处理哪个目录下的资源文件 -->
        <directory>src/main/webapp</dire   ctory>
        <!--注意此次必须要放在此目录下才能被访问到-->
        <targetPath>META-INF/resources</targetPath>
        <includes>
          <include>**/**</include>
        </includes>
      </resource>
      <resource>
        <directory>src/main/resources</directory>
        <includes>
          <include>**/**</include>
        </includes>
        <filtering>false</filtering>
      </resource>
      <resource>
        <directory>src/main/java</directory>
        <excludes>
          <exclude>**/*.java</exclude>
        </excludes>
      </resource>
    </resources>

6.springboot中的日期格式

日期格式的返回

第一种方式属性上加注解

@JsonFormat(pattern = "YYYY-MM-dd")

第二种方式采用配置文件完成自动配置

spring:
  jackson:
    date-format: yyyy-MM-dd HH:mm:ss
    time-zone: GMT+8

日期格式的接受 springboot默认可以转换这种格式 2018/11/11

@DateTimeFormat(pattern = "YYYY-MM-dd")

全局配置文件

spring:
  mvc:
    date-format: yyyy-MM-dd HH:mm:ss

7.文件上传

springboot文件上传的时候需要配置文件上传大小 默认最大文件为1MB 一次请求最大为 10MB

spring:
  http:
    multipart:
      max-file-size: 200MB
      max-request-size: 1000MB

9.springboot注解式aop的开发

1.引入依赖

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-aop</artifactId>
    <version>1.5.8.RELEASE</version>
</dependency>

2.注解式aop相关的注解

@Aspect  //代表切面
@Pointcut  //代表切入点
@Before()   //前置通知
@After()    //后置通知
@Around()   //环绕通知
@AfterThrowing //异常通知

3.切面的开发

@Aspect
@Component
@Slf4j
public class LogAspect {

    @Pointcut(value = "execution(* com.baizhi.service.*.*(..))")
    public void pt(){
        //空方法
    }

//    @After(value = "pt()")
//    //连接点对象为什么声明就能用 原始方法产生的代理类调用的
//    public void aa(JoinPoint joinPoint){
//        //额外功能
//      log.info("========================{}");
//         //原始方法对象
//        Signature signature = joinPoint.getSignature();
//        //方法名
//        String name = joinPoint.getSignature().getName();
//        //参数列表
//        Object[] args = joinPoint.getArgs();
//        //原始方法所在类的对象
//        Object target = joinPoint.getTarget();
//        //代理对象
//        Object aThis = joinPoint.getThis();
//    }
//
//    @Before(value = "pt()")
//    public void bb(JoinPoint joinPoint){
//        //额外功能
//        log.info("+++++++++++++++++++++");
//        //原始方法对象
//        Signature signature = joinPoint.getSignature();
//        //方法名
//        String name = joinPoint.getSignature().getName();
//        //参数列表
//        Object[] args = joinPoint.getArgs();
//        //原始方法所在类的对象
//        Object target = joinPoint.getTarget();
//        //代理对象
//        Object aThis = joinPoint.getThis();
//    }
//
    @Around(value = "pt()")
    public Object cc(ProceedingJoinPoint proceedingJoinPoint){
       log.info("------方法执行之前------------");
        Object proceed =null;
        try {
            //原始方法的返回值
             proceed = proceedingJoinPoint.proceed();
            log.info("this is result=====>{}",proceed);
        } catch (Throwable throwable) {
            throwable.printStackTrace();
        }
        log.info("------方法执行之后------------");
        //必须返回 否则controller拿不到结果
        return proceed;
    }

}