springboot学习中------

springboot诞生背景

多年来，spring大量的xml配置和复杂的依赖一直困扰着java开发人员，Spring Boot是Spring社区发布的一个开源项目，旨在帮助开发者快速并且更简单的构建项目。

springboot是什么

pring boot是由spring官方推出的一个新框架，对spring进行了高度封装，是spring未来的发展方向。spring boot功用众多，其中最主要的功能就是自动化配置，简化开化。

为什么使用springboot

1)独立运行spring项目

spring boot可以以jar包形式独立运行，运行一个spring boot项目只需要通过java -jar xx.jar来运行

2）内嵌servlet容器

Spring Boot可以选择内嵌Tomcat、jetty,这样我们无须以war包形式部署项目。

3）提供starter简化Maven配置
spring提供了一系列的start pom来简化Maven的依赖加载，

4）自动装配Spring
SpringBoot会根据在类路径中的jar包，类、为jar包里面的类自动配置Bean，这样会极大地减少我们要使用的配置。

如何创建springboot项目

（1）new project

（2）选择项目的文件结构及jdk版本 

（3）选择项目所需要的依赖

看下pom文件

<?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.zhangchao.springbootdemo</groupId>
    <artifactId>springbootdemo</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <packaging>jar</packaging>

    <name>springbootdemo</name>
    <description>Demo project for Spring Boot</description>

    <parent>
        <!--继承spring boot的相关配置,主要用于依赖管理，自动配置，日志和yaml.-->
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.0.5.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>
        <!--代表一个spring boot模块，代表web模块，对全栈web开发的支持，包括内置的tomcat, spring-webmvc等。-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <!--jdbc支持-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-jdbc</artifactId>
        </dependency>
        <!--aop的支持-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-aop</artifactId>
        </dependency>
        <!--mySQL的支持-->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
        </dependency>
        <!--mybatis支持-->
        <dependency>
            <groupId>org.mybatis.spring.boot</groupId>
            <artifactId>mybatis-spring-boot-starter</artifactId>
            <version>1.3.0</version>
        </dependency>
        <!--单元测试的支持-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
        <!--热部署的支持-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-devtools</artifactId>
            <optional>true</optional><!--表示两个项目之间依赖不传递-->
        </dependency>
        <!--thymeleaf支持，默认的模板映射路径是：src/main/resources/templates-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-thymeleaf</artifactId>
        </dependency>
    </dependencies>

    <build>
        <plugins>
            <!--默认情况下，maven打包生成的jar文件是用来给其他项目依赖用的，是无法直接运行的。
            spring boot根据自生需要，提供了一个插件来生成可执行jar文件。我们只需要在自己项目的pom.xml中声明这个插件，就会生效
            执行过mvn package打包命令后，target目录会生成*.jar，和*.jar.original
            .jar.original文件仅仅只有原代码，就是maven原版打包的内容
            jar文件是内置了tomcat和spring boot环境，可以直接执行的。在dos命令中，进入jar包所在的路径，执行如下命令： java -jar module-1.0.jar
            -->
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>


</project>

支持热部署配置

1.pom依赖

<!--热部署的支持-->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-devtools</artifactId>
    <optional>true</optional><!--表示两个项目之间依赖不传递-->
</dependency>

2. 在application.yml文件中添加spring:devtools:restart:enabled:true 

或者 application.properties 中添加spring.devtools.restart.enabled=true

3. 按快捷键：crtl+alt+shift+/,找到Registry，点击进入：勾选compiler.automake.allow.when.app.running，点击close，关闭。

 

4. 点击File->Setting->Build,Execution,Deployment->Compiler,在右侧勾选Bulid project automatically,点击Apply，点击Ok关闭。

先看下目录结构 

1. SpringbootdemoApplication 该类在启动的时候会默认扫描它的同级目录和子目录。

2. Application.properties是springboot工程的核心配置文件

3. static目录用来存放网站的静态资源，例如js,css,图片等内容。
4. Templates目录用来存放网站的模板文件，例如freemaker,thymeleaf等

springboot中默认静态资源映射

Spring Boot 默认将 /** 所有访问映射到以下目录：

   classpath:/static

   classpath:/public

   classpath:/resources

   classpath:/META-INF/resources

自定义静态资源映射

在application.properties配置

spring.mvc.static-path-pattern=/static/**

springboot的特点

1. springboot是建立在spring之上的，或者说是以spring为基础的。例如Springboot2.0是以spring5.x为基础的。内置tomcat版本为8.5.
2. springboot遵循的原则是“约定大于配置”。例如：工程的目录结构，配置文件的名称，配置文件中的键值对....
3. 开箱即用，内置了很多组件，只需要进入相应的依赖即可。例如：使用web组件只需要引入spring-boot-starter-web那么springmvc中的注解requestmapping等、内置web容器就自动添加好了。
4. 自动配置，例如我们的tomcat，事务，mybatis等自动配置。
5. 完全兼容spring，即spring支持的，它就支持。

 默认生成的项目启动类

/**
 * 项目启动类
 */
@SpringBootApplication  //@SpringBootApplication是一个组合注解
public class SpringbootdemoApplication {

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

下面看看这个组合注解

@Target({ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Inherited
@SpringBootConfiguration
@EnableAutoConfiguration
@ComponentScan(
    excludeFilters = {
        @Filter(
            type = FilterType.CUSTOM,
            classes = {TypeExcludeFilter.class}
        ), @Filter(
            type = FilterType.CUSTOM,
            classes = {AutoConfigurationExcludeFilter.class}
        )
    }
)
public @interface SpringBootApplication {

//前四个注解：是元注解，用来修饰当前注解，就像public类的修饰词，没有实际功能
//@SpringBootConfiguration：当前类是一个配置类，就像xml配置文件
//@EnableAutoConfiguration：这就是spring boot的核心功能，自动配置。就是根据当前引入的JAR包进行自动配置，比如：
        //引入了spring boot的web模块，就会自动配置web.xml等与web项目相关的内容，所以这些配置都不需要我们自己配了
//@ComponentScan：用注解配置实现自动扫描，默认会扫描当前包和所有子包，和xml配置自动扫描效果一样，@Filter是排除了两个系统类

运行项目启动类 

说下springboot中其中一个注解 RestController，他是ResponseBody和@Controller的组合

 springMVC开发的时候需要我们提供json接口的时候需要

（1）添加jackson等相关的jar包

（2）配置spring controller扫描

（3）对接的方法添加@ResponseBody注解

然而springboot，只需要类添加@RestCOntroller即可，默认类的方法都会以json的格式返回。

同时springboot也简化了@RequestMapping注解

springboot中使用事务支持

1. 加入JDBC依赖，此时就可以自动的配置上述XML中的TrasactionManager对象
2. 在需要的方法上使用@Trasactional注解
3. spring boot同样自动配置好了事务，在service层 只需要一个注解即可使用，例子：

dao层

@Repository
public interface UserDao {

    List<User> getUser();

    Integer addUser(User user);

    Integer addUserClass(UserClass userClass);

}

mapping

 <insert id="addUser" parameterType="user">
        <selectKey resultType="integer" order="AFTER" keyProperty="id">
          select last_insert_id()
        </selectKey>
        insert into user(<include refid="insertSql"></include>) values(
          #{username},#{password},#{age},#{job}
        )
    </insert>

    <insert id="addUserClass" parameterType="userClass">
        insert into user_class (<include refid="insertSql2"></include>) values(
          #{id},#{uid},#{className}
        )
    </insert>

 service层

public interface UserService {

    List<User> getUser();

    Integer addUserAndUserClass(User user, UserClass userClass);

}

service实现层 

   /**
     *  Transactional 声明在类上面：类的所有方法有效,声明在方法上面：该方法有效
     * @param user
     * @param userClass
     * @return
     */
    @Transactional
    @Override
    public Integer addUserAndUserClass(User user, UserClass userClass) {
        userDao.addUser(user);
//        userClass.setUid(user.getId()); //测试事务，发生异常时，是否会回滚
        Integer row = userDao.addUserClass(userClass);
        System.out.println(row+"=================");
        return row;
    }

 事务test类

@RunWith(SpringRunner.class)
@MapperScan("com.zhangchao.springboot.dao") //必须扫描dao层
@SpringBootTest
public class SpringbootdemoApplicationTests {
    @Autowired
    private UserService userService;
    
    /**
     * 测试springboot事务，如果serviceImp中userClass有id，则正常执行，若没有，则发生异常，
     *  serviceImp中两个方法都不执行    
     */
    @Test
    public void addUserAndUserClass() {
        User user = new User();
        user.setAge(33);
        user.setJob("学生");
        user.setUsername("wangba");
        user.setPassword("admin");

        UserClass userClass = new UserClass();
        userClass.setClassName("八班");

        userService.addUserAndUserClass(user,userClass);

    }

}

在springboot中使用日志

1.日志的级别

debug-info-warn-error

2.日志的级别越低则输出的内容越多，越详细。

3.通过配置使用slf4j日志

在application.properties文件中通过设置以下键值对来配置日志：

logging.level.org.springframework=debug

logging.file=springboot.log

springboot会根据配置，每天生产一个log文件，如果配置了文件大的最大尺寸则满足最大尺寸的时候会再次生成一个新的log文件，如图：

例子：controller层

@RestController   //页面数据以json格式输出，如下个方法，以及下面图片
@RequestMapping("/user")
public class UserController {

    private static org.slf4j.Logger Logger =  LoggerFactory.getLogger(UserController.class);
    @Resource
    private UserService userService;

    @RequestMapping("/getUser")
    public List<User> getUser(){
        List<User> user = userService.getUser();

        for (User user1 : user) {
            System.out.println(user1);
            // 测试springboot日志功能
            Logger.error("=========="+user1);
        }
        return user;
    }
}

默认异常处理

Spring Boot提供了一个默认的映射：/error，当处理中抛出异常之后，会转到该请求中处理，并且该请求有一个全局的错误页面用来展示异常内容。

springboot定时任务

1、启动类启用定时

在启动类上面加上@EnableScheduling即可开启定时

/**
 * 项目启动类
 */
@ServletComponentScan //扫描servlet注解
@EnableScheduling //开启spring定时任务
@MapperScan(basePackages = "com.zhangchao.springboot.dao")//mybatis注解，扫描mapper接口文件
@SpringBootApplication
public class SpringbootdemoApplication {

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

2、创建定时任务实现类

@Component
public class SchedulerTask {

    private AtomicInteger num = new AtomicInteger(0);
    private SimpleDateFormat format = new SimpleDateFormat("yyyy-MM--dd HH:mm:ss");

    /**
     * corn表达式 6s一次
     */
    @Scheduled(cron = "*/6 * * * * ?")
    private void countNum(){
        System.out.println("定时任务触发次数 "+num.getAndIncrement());
    }
    /**
     *  6s一次
     */
    @Scheduled(fixedRate = 6000)
    private void currentTime(){
        System.out.println("定时任务当前时间： "+format.format(new Date()));
    }

}

AtomicInteger原子类型

运行项目启动类结果：

• @Scheduled(fixedRate = 6000) ：上一次开始执行时间点之后6秒再执行；
• @Scheduled(fixedDelay = 6000) ：上一次执行完毕时间点之后6秒再执行；
• @Scheduled(initialDelay=1000, fixedRate=6000) ：第一次延迟1秒后执行，之后按fixedRate的规则每6秒执行一次。

springboot 配置AOP切面

1、添加依赖

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

2、切面类 ，使用 @Component，@Aspect 标记到切面类上：

@Component
@Aspect
public class TimeAspect {
    @Around("execution(* com.zhangchao.springboot.controller..*(..))")
    public Object timeMethod(ProceedingJoinPoint joinPoint) throws Throwable{
        System.out.println("===========================Aspect处理 - start ==========================");
        Object[] args = joinPoint.getArgs();
        for (Object arg : args) {
            System.out.println("参数： "+arg);
        }
        long startTime = System.currentTimeMillis();
        Object o = joinPoint.proceed();
        System.out.println("aop耗时 "+(System.currentTimeMillis()-startTime));
        System.out.println("===========================Aspect处理 - end =============================");
        return o;
    }

}

springboot项目添加webapp 

获取配置文件的参数值

 application.properties

user.id=${random.int}
user.username=qixing${random.value}
user.pwd=admin${random.uuid}
user.age=user.age=${random.int[10,100]}
user.job=教师

 User类，省略getset

@Component
@ConfigurationProperties(prefix = "user")
public class User {

    private Integer id;
    private Integer age;
    private String username;
    /**
     *  当配置文件中属性名与实体类属性名有区别时，使用@value
     */
    @Value("${user.pwd}")
    private String password;
    private String job;

测试

package com.zhangchao.springboot.commandLineRunner;

import com.zhangchao.springboot.entity.User;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.ApplicationArguments;
import org.springframework.boot.ApplicationRunner;
import org.springframework.stereotype.Component;

/**
 * 〈CommandLineRunner和ApplicationRunner〉
 *
 *  容器启动完成时执行run方法中内容
 *  注意添加 @Component
 *
 *  获取 application-dev.properties 中user配置的属性
 * @author 22902
 * @create 2018/11/15
 */
/*@Component
public class TestCommandLineRunner implements CommandLineRunner {
    @Autowired
    private User user;
    @Override
    public void run(String... args) throws Exception {
        System.out.println(user.toString());
    }
}*/
@Component
public class TestCommandLineRunner implements ApplicationRunner {
    @Autowired
    private User user;

    @Override
    public void run(ApplicationArguments args) throws Exception {
        System.out.println(user.toString());
    }

}

 输出

User{id=1250477733age=30, username='qixing74e3c8284d60295d05e46bd55aae83a6', password='admin3304d20a-6818-4451-99f5-882381f60912', job='教师'}

 random.* 属性

Spring Boot 通过 RandomValuePropertySource 提供了很多关于随机数的工具类。

可以生成随机字符串、随机 int 、随机 long、某范围的随机数。

多环境配置

Spring Boot 是通过 application.properties 文件中，设置 spring.profiles.active 属性，比如 ，配置了 dev ,则加载的是 application-dev.properties ，必须是这种格式 application-xxxx.properties

# 定义读取的properties文件
spring.profiles.active=dev
# 定义读取的properties文件,可以多个，逗号隔开
#spring.profiles.include=dev,prod