今天完成的事情：（一定要写非常细致的内容，比如说学会了盒子模型，了解了Margin） 

继续学习springboot日志部分；

如何让系统中所有的日志都统一到slf4j；

1、将系统中其他日志框架先排除出去；

2、用中间包来替换原有的日志框架；

3、我们导入slf4j其他的实现

<dependency>

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

<artifactId>spring‐boot‐starter</artifactId>

</dependency>

pringBoot使用它来做日志功能；

<dependency>

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

<artifactId>spring‐boot‐starter‐logging</artifactId>

</dependency>

底层依赖关系

总结：

1）、SpringBoot底层也是使用slf4j+logback的方式进行日志记录

2）、SpringBoot也把其他的日志都替换成了slf4j；

4）、如果我们要引入其他框架？一定要把这个框架的默认日志依赖移除掉？

Spring框架用的是commons-logging；

<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring‐core</artifactId>
    <exclusions>
        <exclusion>
            <groupId>commons‐logging</groupId>
            <artifactId>commons‐logging</artifactId>
        </exclusion>
    </exclusions>
</dependency>

SpringBoot能自动适配所有的日志，而且底层使用slf4j+logback的方式记录日志，引入其他框架的时候，只需要

把这个框架依赖的日志框架排除掉即可；

日志使用：
默认配置

SpringBoot默认帮我们配置好了日志；

//记录器

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

@Test

public void contextLoads() {

//System.out.println();

//日志的级别；

//由低到高 trace<debug<info<warn<error

//可以调整输出的日志级别；日志就只会在这个级别以以后的高级别生效

logger.trace("这是trace日志...");

logger.debug("这是debug日志...");

//SpringBoot默认给我们使用的是info级别的，没有指定级别的就用SpringBoot默认规定的级别；root

级别

logger.info("这是info日志...");

logger.warn("这是warn日志...");

logger.error("这是error日志...");

}

日志输出格式：

%d表示日期时间，

%thread表示线程名，

%‐5level：级别从左显示5个字符宽度

%logger{50} 表示logger名字最长50个字符，否则按照句点分割。

%msg：日志消息，

%n是换行符

‐‐>

%d{yyyy‐MM‐dd HH:mm:ss.SSS} [%thread] %‐5level %logger{50} ‐ %msg%n

SpringBoot修改日志的默认配置

logging.level.com.atguigu=trace

#logging.path=

# 不指定路径在当前项目下生成springboot.log日志

# 可以指定完整的路径；

#logging.file=G:/springboot.log

# 在当前磁盘的根路径下创建spring文件夹和里面的log文件夹；使用 spring.log 作为默认文件

logging.path=/spring/log

# 在控制台输出的日志的格式

logging.pattern.console=%d{yyyy‐MM‐dd} [%thread] %‐5level %logger{50} ‐ %msg%n

# 指定文件中日志输出的格式

logging.pattern.file=%d{yyyy‐MM‐dd} === [%thread] === %‐5level === %logger{50} ==== %msg%n

2、指定配置

给类路径下放上每个日志框架自己的配置文件即可；SpringBoot就不使用他默认配置的了

logback.xml：直接就被日志框架识别了；

logback-spring.xml：日志框架就不直接加载日志的配置项，由SpringBoot解析日志配置，可以使用SpringBoot的高级Profile功能

如：

<appender name="stdout" class="ch.qos.logback.core.ConsoleAppender">

<!‐‐

日志输出格式：

%d表示日期时间，

%thread表示线程名，

%‐5level：级别从左显示5个字符宽度

%logger{50} 表示logger名字最长50个字符，否则按照句点分割。

%msg：日志消息，

%n是换行符

‐‐>

<layout class="ch.qos.logback.classic.PatternLayout">

<springProfile name="dev">

<pattern>%d{yyyy‐MM‐dd HH:mm:ss.SSS} ‐‐‐‐> [%thread] ‐‐‐> %‐5level %logger{50} ‐ %msg%n</pattern>

</springProfile>

<springProfile name="!dev">

<pattern>%d{yyyy‐MM‐dd HH:mm:ss.SSS} ==== [%thread] ==== %‐5level %logger{50} ‐ %msg%n</pattern>

</springProfile>

</layout>

</appender>

切换日志框架

可以按照slf4j的日志适配图，进行相关的切换；

slf4j+log4j的方式；

<dependency>

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

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

<exclusions>

<exclusion>

<artifactId>logback‐classic</artifactId>

<groupId>ch.qos.logback</groupId>

</exclusion>

<exclusion>

<artifactId>log4j‐over‐slf4j</artifactId>

<groupId>org.slf4j</groupId>

</exclusion>

</exclusions>

</dependency>

<dependency>

<groupId>org.slf4j</groupId>

<artifactId>slf4j‐log4j12</artifactId>

</dependency>

<dependency>

切换为log4j2

<dependency>

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

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

<exclusions>

<exclusion>

<artifactId>spring‐boot‐starter‐logging</artifactId>

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

</exclusion>

</exclusions>

</dependency>

<dependency>

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

<artifactId>spring‐boot‐starter‐log4j2</artifactId>

</dependency>

开始写SpringBootWeb程序

Idea 构建项目

• 1、选择 File -> New —> Project... 弹出新建项目的框
• 2、选择 Spring Initializr，Next 也会出现上述类似的配置界面，Idea 帮我们做了集成
• 3、填写相关内容后，点击 Next 选择依赖的包再点击 Next，最后确定信息无误点击 Finish。

我选择第一个依赖。

项目结构介绍

如上图所示，Spring Boot的基础结构共三个文件:

l src/main/java  程序开发以及主程序入口

l src/main/resources 配置文件

l src/test/java  测试程序

另外，spingboot建议的目录结果如下：

root package结构：com.jnshu.web-demo

com

  +- jnshu

    +- webdemo

      +- WebDemoApplication.java

      |

      +- domain

      |  +- Customer.java

      |  +- CustomerRepository.java

      |

      +- service

      |  +- CustomerService.java

      |

      +- controller

      |  +- CustomerController.java      |

1、XXXApplication.java 建议放到根目录下面,主要用于做一些框架配置

2、domain目录主要用于实体（Entity）与数据访问层（Repository）

3、service 层主要是业务类代码

4、controller 负责页面访问控制

 单元测试：
打开的src/test/下的测试入口，编写简单的http请求来测试；使用mockmvc进行，利用MockMvcResultHandlers.print()打印出执行结果。

也可以用日志打印。

springboot和数据访问：

1.JDBC

依赖：

<?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 https://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>com.jnshu</groupId>
    <artifactId>jdbc</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <packaging>jar</packaging>

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

    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.1.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>
        <!--核心模块，包括自动配置支持、日志和YAML-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter</artifactId>
        </dependency>
        <!--测试模块，包括JUnit、Hamcrest、Mockito。-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
        <!--jdbc-->
        <!-- https://mvnrepository.com/artifact/org.springframework.boot/spring-boot-starter-jdbc -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-jdbc</artifactId>
        </dependency>
        <!--mysql连接-->
        <!-- https://mvnrepository.com/artifact/mysql/mysql-connector-java -->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <scope>runtime</scope>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
    </dependencies>

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

</project>

配置文件application.properties

spring:
  datasource:
    username: root
    password: 123456
    url: jdbc:mysql://101.132.124.42:3306/jdbc
    driver‐class‐name: com.mysql.jdbc.Driver

修改配置文件为application.yml

spring:
  datasource:
    username: root
        password: 123456
        url: jdbc:mysql://101.132.124.42:3306/jdbc
        driver‐class‐name: com.mysql.jdbc.Driver

这样的配置，默认使用HikariDataSource数据源

com.zaxxer.hikari.HikariDataSource

创建一个Controller类

此类通过Spring自带的JdbcTemplate类来查询数据库中的数据

package com.jnshu.jdbc.controller;


import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

import java.util.List;
import java.util.Map;

@RestController
@RequestMapping("/jdbc")
public class JdbcController {
    @Autowired
    JdbcTemplate jdbcTemplate;

    @GetMapping("/list")
    public List<Map<String,Object>> queryUsers(){
        List<Map<String,Object>> list=jdbcTemplate.queryForList("select * from users");
        return list;
    }
}

启动，postman测试

但是这里没有配置实体类和接口等，不是一个完整的分层程序。

Spring对数据库的操作在jdbc上面做了深层次的封装，使用spring的注入功能，可以把DataSource注册到JdbcTemplate之中。 JdbcTemplate 是在JDBC API基础上提供了更抽象的封装，并提供了基于方法注解的事务管理能力。 通过使用SpringBoot自动配置功能并代替我们自动配置beans.

数据源配置
在maven中，我们需要增加spring-boot-starter-jdbc模块
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-jdbc</artifactId>
</dependency>

通过这个模块为我们做了以下几件事
    tomcat-jdbc－{version}.jar为我们自动配置DataSource.
    如果你没有定义任何DataSource，SpringBoot将会自动配置一个内存的数据库资源设置
    如果没有设置任一个beans，SpringBoot会自动注册它
    初始化数据库
    如果我们在classpath里定义了schema.sql和data.sql文件，springBoot将会使用这些文件自动初始化数据库(但你必须选建库)
    除了载入schema.sql和data.sql外，SpringBoot也会载入schema-${platform}.sql和data-${platform}.sql，如果在你的classpath下存在的话。
    spring.datasource.schema=xxxx-db.sql 可以定义你的建库文件
    spring.datasource.data=xxxx-data.sql  可以定义你的数据文件
    spring.datasource.initialize＝true|false 可以决定是不是要初始化这些数据库文件
    spring.datasource.continueOnError＝true|false 有了错误是否继续运行

嵌入式数据库支持
嵌入式数据库通常用于开发和测试环境，不推荐用于生产环境。Spring Boot提供自动配置的嵌入式数据库有H2、HSQL、Derby，你不需要提供任何连接配置就能使用。
比如，我们可以在pom.xml中引入如下配置使用HSQL
<dependency>
    <groupId>org.hsqldb</groupId>
    <artifactId>hsqldb</artifactId>
    <scope>runtime</scope>
</dependency>

连接生产数据源配置
以MySQL数据库为例，先引入MySQL连接的依赖包，在pom.xml中加入：
<dependency>
    <groupId>mysql</groupId>
    <artifactId>mysql-connector-java</artifactId>
    <version>5.1.37</version>
</dependency>

在src/main/resources/application.properties中配置数据源信息
spring.datasource.url=jdbc:mysql://localhost:3306/test
spring.datasource.username=dbuser
spring.datasource.password=dbpass
spring.datasource.driver-class-name=com.mysql.cj.jdbc.Driver

连接JNDI数据源配置
当你将应用部署于应用服务器上的时候想让数据源由应用服务器管理，那么可以使用如下配置方式引入JNDI数据源。
spring.datasource.jndi-name=java:jboss/datasources/customers

自定义数据源配置
如果你不想用默认的配置数据源，如你想用阿里巴巴的数据池管理数据源，你也可以自己配置
先排除tomcat-jdbc的默认配置dataSource
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-jdbc</artifactId>
    <exclusions>
        <exclusion>
            <groupId>org.apache.tomcat</groupId>
            <artifactId>tomcat-jdbc</artifactId>
        </exclusion>
    </exclusions>
</dependency>

定义自己的数据资源 这里使用了阿里巴巴的数据池管理,你也可以使用BasicDataSource
<dependency>
    <groupId>com.alibaba</groupId>
    <artifactId>druid</artifactId>
    <version>1.0.19</version>
</dependency>

在启动类程序中配置：

package com.jnshu.jdbc;

import com.alibaba.druid.pool.DruidDataSource;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.annotation.Bean;
import org.springframework.core.env.Environment;

import javax.sql.DataSource;

@SpringBootApplication
public class JdbcApplication {
    @Autowired
    private Environment env;

    @Bean
    public DataSource dataSource(){
        DruidDataSource dataSource = new DruidDataSource();
        dataSource.setUrl(env.getProperty("spring.datasource.url"));
        dataSource.setUsername(env.getProperty("spring.datasource.username"));//用户名
      dataSource.setPassword(env.getProperty("spring.datasource.password"));//密码
      dataSource.setDriverClassName(env.getProperty("spring.datasource.driver-class-name"));
        dataSource.setInitialSize(2);
        dataSource.setMaxActive(20);
        dataSource.setMinIdle(0);
        dataSource.setMaxWait(60000);
        dataSource.setValidationQuery("SELECT 1");
        dataSource.setTestOnBorrow(false);
        dataSource.setTestWhileIdle(true);
        dataSource.setPoolPreparedStatements(false);
        return dataSource;
    }

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

}

你也可以用别的：
<dependency>
    <groupId>commons-dbcp</groupId>
    <artifactId>commons-dbcp</artifactId>
    <version>1.4</version>
</dependency>

@Bean
public DataSource dataSource() {
    BasicDataSource dataSource = new BasicDataSource();
    dataSource.setDriverClassName(env.getProperty("spring.datasource.driver-class-name"));
    dataSource.setUrl(env.getProperty("spring.datasource.url"));
    dataSource.setUsername(env.getProperty("spring.datasource.username"));
    dataSource.setPassword(env.getProperty("spring.datasource.password"));
    return dataSource;
}

创建实体对象
/src/main/java/com/jnshu/jdbc/domain/User.java

package com.jnshu.jdbc.domain;

public class User {
    private Integer id;
    private String username;
    private String password;
    private String phone;

    public User() {
    }

    public User(Integer id, String username, String password, String phone) {
        this.id = id;
        this.username = username;
        this.password = password;
        this.phone = phone;
    }

    public Integer getId() {
        return id;
    }

    public void setId(Integer id) {
        this.id = id;
    }

    public String getUsername() {
        return username;
    }

    public void setUsername(String username) {
        this.username = username;
    }

    public String getPassword() {
        return password;
    }

    public void setPassword(String password) {
        this.password = password;
    }

    public String getPhone() {
        return phone;
    }

    public void setPhone(String phone) {
        this.phone = phone;
    }

    @Override
    public String toString() {
        return "User{" +
                "id=" + id +
                ", username='" + username + '\'' +
                ", password='" + password + '\'' +
                ", phone='" + phone + '\'' +
                '}';
    }
}

创建持久层
有了上面的数据源配置，我们可以注入JdbcTemplate到数据访问组件并与数据库交互。 
/src/main/java/com/jnshu/jdbc/repositories/UserRepository.java

package com.jnshu.jdbc.repositories;

import com.jnshu.jdbc.domain.User;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.jdbc.core.PreparedStatementCreator;
import org.springframework.jdbc.core.RowMapper;
import org.springframework.jdbc.support.GeneratedKeyHolder;
import org.springframework.jdbc.support.KeyHolder;
import org.springframework.stereotype.Repository;
import org.springframework.transaction.annotation.Transactional;

import java.sql.*;
import java.util.List;

@Repository
public class UserRepository {
    @Autowired
    private JdbcTemplate jdbcTemplate;

    @Transactional(readOnly = true)
    public List<User> findAll(){
        return jdbcTemplate.query("select * from users",new UserRowMapper());
    }

    @Transactional(readOnly = true)
    public User findUserById(int id){
        return jdbcTemplate.queryForObject("select * from users where id=?",new Object[]{id},new UserRowMapper());
    }

    //新增
    public User create(final User user){
        final String sql="insert into users(username,password,phone) values(?,?,?)";
        KeyHolder holder=new GeneratedKeyHolder();
        jdbcTemplate.update(new PreparedStatementCreator() {
            @Override
            public PreparedStatement createPreparedStatement(Connection connection) throws SQLException {
                PreparedStatement ps=connection.prepareStatement(sql, Statement.RETURN_GENERATED_KEYS);
                ps.setString(1,user.getUsername());
                ps.setString(2,user.getPassword());
                ps.setString(3,user.getPhone());
                return ps;
            }
        },holder);
        int newUserId=holder.getKey().intValue();
        user.setId(newUserId);
        return user;
    }
    //删除
    public void delete(final Integer id) {
        final String sql = "delete from users where id=?";
        jdbcTemplate.update(sql,
                new Object[]{id},
                new int[]{java.sql.Types.INTEGER});
    }

    public void update(final User user) {
        jdbcTemplate.update(
                "update users set username=?,password=?,phone=? where id=?",
                new Object[]{user.getUsername(), user.getPassword(), user.getPhone(),user.getId()});
    }
}

    

    class UserRowMapper implements RowMapper<User> {

    @Override
    public User mapRow(ResultSet rs, int rowNum) throws SQLException {
        User user = new User();
        user.setId(rs.getInt("id"));
        user.setUsername(rs.getString("username"));
        user.setPassword(rs.getString("password"));
        user.setPhone(rs.getString("phone"));

        return user;
    }
}

单元测试

大多数时候，我们都在应用中做这些配置的事。
创建单元测试测试我们的持久层方法

package com.jnshu.jdbc;

import com.jnshu.jdbc.domain.User;
import com.jnshu.jdbc.repositories.UserRepository;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.context.junit4.SpringRunner;
import java.util.List;
import static org.junit.Assert.*;
import static org.junit.Assert.assertEquals;


@RunWith(SpringRunner.class)
@SpringBootTest
public class JdbcApplicationTests {
    Logger logger= LoggerFactory.getLogger(JdbcApplicationTests.class);
    @Autowired
    private UserRepository userRepository;

    @Test public void testAll(){
        findAllUsers();
        findUserById();
        createUser();
    }

    @Test
    public void findAllUsers()  {
        List<User> users = userRepository.findAll();
        assertNotNull(users);
        assertTrue(!users.isEmpty());
    }

    @Test
    public void findUserById()  {
        User user = userRepository.findUserById(1);
        assertNotNull(user);
    }

    private void updateById(Integer id)  {
        User newUser = new User(id, "JackChen", "123456","13554564964");
        userRepository.update(newUser);
        User newUser2 = userRepository.findUserById(newUser.getId());
        assertEquals(newUser.getUsername(), newUser2.getUsername());
        assertEquals(newUser.getPassword(), newUser2.getPassword());
        assertEquals(newUser.getPhone(), newUser2.getPhone());
    }
    @Test
    public void createUser() {
        User user = new User(0, "tom","123456", "13584568524");
        User savedUser = userRepository.create(user);
        logger.debug("{}",savedUser);
        User newUser = userRepository.findUserById(savedUser.getId());
        assertEquals("tom", newUser.getUsername());
        assertEquals("123456", newUser.getPassword());
        assertEquals("13584568524", newUser.getPhone());
        updateById(newUser.getId());
        userRepository.delete(newUser.getId());
    }
}

明天计划的事情：（一定要写非常细致的内容） 
遇到的问题：（遇到什么困难，怎么解决的） 
收获：（通过今天的学习，学到了什么知识）