springboot学习04（从搭建到熟悉）

springboot整合JDBC使用

一个网站离不开与数据库的交互，我们在创建springboot项目的时候，需要勾选至少以下组件。此处以JDBC为例子。

之后需要在项目中，引入jdbc和MYSQL的驱动依赖。

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

        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <scope>runtime</scope>
        </dependency>

之后我们需要在application.yaml文件中，定义数据库的连接设置。包含登录用户和密码，和ssm框架差不多的写法。

spring:
  datasource:
    username: root
    password: 697394
    url: jdbc:mysql://localhost:3306/mybatis?useUnicode=true&characterEncoding=utf-8
    driver-class-name: com.mysql.cj.jdbc.Driver

测试连接：（如果能输出数据源，基本就没啥问题）

package com.chaoxi;

import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;

import javax.sql.DataSource;
import java.sql.Connection;
import java.sql.SQLException;

@SpringBootTest
class Springboot04DataApplicationTests {

    @Autowired
    DataSource dataSource;

    @Test
    void contextLoads() throws SQLException {

        //查看一下默认的数据源 ；class com.zaxxer.hikari.HikariDataSource
        System.out.println(dataSource.getClass());

        //获取数据库连接(我没有配置时区，也没报错)
        Connection connection = dataSource.getConnection();
        System.out.println(connection);

        //springboot中有很多xxx Template：springboot已经配置好模板bean,拿来即用
        //jdbc
        //redis

        //用完后要关闭连接
        connection.close();
    }

}

进行jdbc的使用测试：
当我们引入jdbc的依赖的时候，其就存在了JdbcTemplate对象供我们使用，我们直接注入后，就可以使用jdbc的模板了。代码如下：他的里面存在可很多模板，我们只需要定义好sql语句和参数后，就可传入对应的实现方法就行了。

package com.chaoxi;

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.PathVariable;
import org.springframework.web.bind.annotation.RestController;

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

/**
 * @author chaoxi
 * @create 2022-04-08 21:40
 */
@RestController //这样就返回的显示的就是字符串了

public class JDBController {

    @Autowired
    JdbcTemplate jdbcTemplate;


    @GetMapping("/userlist")
    public List<Map<String,Object>> queryAll(){
        String sql = "select * from user";
        List<Map<String, Object>> list_maps = jdbcTemplate.queryForList(sql);
        return list_maps;
    }

    @GetMapping("/addUser")
    public String addUser(){
        String sql = "insert into mybatis.user(id,name,pwd) values(9,'chaochao','789456123')";
        jdbcTemplate.update(sql);
        return "add_ok";
    }

    @GetMapping("/updateUser/{id}")
    public String updateUser(@PathVariable("id")int id){
        String sql = "update mybatis.user set name=?,pwd=? where id="+id;
        Object[] objects = new Object[2];
        objects[0]="小明2";
        objects[1]="zzzzzzzzz";
        jdbcTemplate.update(sql,objects);
        return "update_ok";
    }

    @GetMapping("/deleteUser/{id}")
    public String deleteUser(@PathVariable("id")int id){
        String sql = "delete from mybatis.user where id=?";

        jdbcTemplate.update(sql,id);
        return "delete_ok";
    }
    
}

整个Druid数据源

Druid是阿里巴巴开源平台上一个数据库连接池实现，结合了C3P0,DBCP,PROXOOL等DB池的优点，同时加入了日志监控。Druid可以很好的监控DB池连接和SQL的执行情况，天生就是针对监控而生的DB连接池。
Springboot2.0以上默认使用Hikari数据源，可以说Hikari和Druid都是当前JAVA WEB上最优秀的数据源。
首先我们需要引入依赖：

<!-- https://mvnrepository.com/artifact/com.alibaba/druid -->
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>druid</artifactId>
            <version>1.1.21</version>
        </dependency>

请注意，由于Druid是由阿里巴巴开发，所以如果maven使用默认的地址仓库，可能无法下载Druid的jar包，需要在setting.xml中，设置一个阿里云的镜像源。这样才能下载到对应的jar包。
之后我们在application.yaml中设置数据源，使其生效。

spring:
  datasource:
    username: root
    password: 697394
    url: jdbc:mysql://localhost:3306/mybatis?useUnicode=true&characterEncoding=utf-8
    driver-class-name: com.mysql.cj.jdbc.Driver
    type: com.alibaba.druid.pool.DruidDataSource

    #springboot默认是不注入这些属性值的，需要自己绑定
    #druid 数据源专有配置
    initialSize: 5
    minIdle: 5
    maxActive: 20
    maxWait: 60000
    timeBetweenEvictionRunsMillis: 60000
    minEvictableIdleTimeMillis: 300000
    validationQuery: SELECT 1 FROM DUAL
    testWhileIdle: true
    testOnBorrow: false
    testOnReturn: false
    poolPreparedStatements: true

    #配置监控统计拦截的filters,stat:监控统计，log4j：日志记录 ，wall：防御sql注入
    filters: stat,wall,log4j
    maxPoolPreparedStatementPerConnectionSize: 20
    useGlobalDateSourceStat: true
    connecttionProperties: druid.stat.mergeSql=true;druid.stat.slowSqlMillis=500

由于我们配置了log4j的日志监控，所以我们需要额外引入，log4j的依赖。

<dependency>
            <groupId>log4j</groupId>
            <artifactId>log4j</artifactId>
            <version>1.2.17</version>
        </dependency>

我们发现，两个数据源的效果是一致的。同时，由于我们引入了log4j的日志监控，所以还需要对log4j进行配置
在resources目录下新建，log4j.properties。
写入配置：

log4j.rootLogger=DEBUG, stdout
log4j.appender.stdout=org.apache.log4j.ConsoleAppender
log4j.appender.stdout.layout=org.apache.log4j.PatternLayout
log4j.appender.stdout.layout.ConversionPattern=%5p [%t] - %m%n

之后我们需要在config文件中，配置Druid的数据源配置。相当于以前的xml文件。包含，后台监控的登录，过滤器。

package com.chaoxi.config;

import com.alibaba.druid.pool.DruidDataSource;
import com.alibaba.druid.support.http.StatViewServlet;
import com.alibaba.druid.support.http.WebStatFilter;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.boot.web.servlet.FilterRegistrationBean;
import org.springframework.boot.web.servlet.ServletRegistrationBean;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

import javax.servlet.Filter;
import javax.sql.DataSource;
import java.util.HashMap;

/**
 * @author chaoxi
 * @create 2022-04-11 10:40
 */
@Configuration
public class DruidConfig {

    @ConfigurationProperties(prefix = "spring.datasource")  //绑定application中的配置
    @Bean
    public DataSource druidDataSource(){
        return new DruidDataSource();
    }

    //定制drudi的后台监控,web.xml ServletRegistrationBean
    //因为springboot内置了serlet容器，所有没有web.xml.替代方法：ServletRegistrationBean
    @Bean
    public ServletRegistrationBean statViewServlet(){
        ServletRegistrationBean<StatViewServlet> bean = new ServletRegistrationBean<>(new StatViewServlet(), "/druid/*");
        //后台需要有人监控，账号密码配置
        HashMap<String, String> initParameters = new HashMap<>();
        //增加配置
        initParameters.put("loginUsername","admin"); //设置的loginUsername，password是固定的字段，不能更改
        initParameters.put("loginPassword","123456");

        //允许谁可以访问
        initParameters.put("allow",""); //为空的话，就是所有人都可以访问

        //禁止谁能访问  initParameters.put("kuangshen","192.168.11.123");


        bean.setInitParameters(initParameters);
        return bean;
    }

    //过滤器
    @Bean
    public FilterRegistrationBean webStatFilter(){
        FilterRegistrationBean<Filter> bean = new FilterRegistrationBean<>();
        bean.setFilter(new WebStatFilter());

        //可以过滤那些请求
        HashMap<String, String> initParameters = new HashMap<>();

        initParameters.put("exclusions","*.js,*.css,/druid/*");

        bean.setInitParameters(initParameters);
        return bean;
    }
}

启动服务，我们就可以看到，当我们执行一些sql时，网页中对我们的操作进行记录。

log4j的日志信息。

整合mybatis

首先我们得引入mybatis得依赖

<!-- https://mvnrepository.com/artifact/org.mybatis.spring.boot/mybatis-spring-boot-starter -->
        <dependency>
            <groupId>org.mybatis.spring.boot</groupId>
            <artifactId>mybatis-spring-boot-starter</artifactId>
            <version>2.1.3</version>
        </dependency>

配置数据库连接：

spring:
  datasource:
    username: root
    password: 697394
    url: jdbc:mysql://localhost:3306/mybatis?serverTimezone=UTC&useUnicode=true&characterEncoding=utf-8
    driver-class-name: com.mysql.cj.jdbc.Driver

为数据库中得表建立对应得数据对象：

编写mapper接口，定义CRUD方法：

import com.chaoxi.pojo.User;
import org.apache.ibatis.annotations.Mapper;
import org.springframework.stereotype.Repository;

import java.util.List;

/**
 * @author chaoxi
 * @create 2022-04-11 15:16
 */
//这个注解表示了这是一个mybatis的mapper类。dao
@Mapper
@Repository
public interface UserMapper {

    List<User> queryUserList();

    User queryUserById(int id);

    int addUser(User user);

    int updateUserInfo(User user);

    int deleteUserInfo(int id);
}

根据mapper接口，书写sql语句。并在application.yaml中配置mybatis得配置

spring:
  datasource:
    username: root
    password: 697394
    url: jdbc:mysql://localhost:3306/mybatis?serverTimezone=UTC&useUnicode=true&characterEncoding=utf-8
    driver-class-name: com.mysql.cj.jdbc.Driver
mybatis:
  type-aliases-package: com.chaoxi.pojo
  mapper-locations: classpath:mybatis/mapper/*.xml

这个得书写和以前是一样得。

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper
        PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-mapper.dtd">

<mapper namespace="com.chaoxi.mapper.UserMapper">

    <select id="queryUserList" resultType="User">
        select * from user;
    </select>

    <select id="queryUserById" resultType="User" parameterType="int">
        select * from user where id = #{id};
    </select>

    <insert id="addUser" parameterType="User">
        insert into user(id,name,pwd) values (#{id},#{name},#{pwd});
    </insert>

    <update id="updateUserInfo" parameterType="User">
        update user set name=#{name},pwd=#{pwd} where id=#{id};
    </update>

    <delete id="deleteUserInfo" parameterType="int">
        delete from user where id=#{id};
    </delete>
</mapper>

编写controller，进行查询测试。

package com.chaoxi.controller;

import com.chaoxi.mapper.UserMapper;
import com.chaoxi.pojo.User;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.ResponseBody;

import java.util.List;

/**
 * @author chaoxi
 * @create 2022-04-11 15:38
 */
@Controller
@ResponseBody //返回的是json格式
public class UserController {

    @Autowired
    private UserMapper userMapper;

    //@RequestMapping("/queryUserlist")
    @GetMapping("/queryUserlist")
    public List<User> queryUserList(){
        List<User> userslist = userMapper.queryUserList();
        System.out.println(userslist);
        return userslist;
    }

    @GetMapping("/queryUserById/{id}")
    public User queryUserById(@PathVariable("id")int id){
        User user = userMapper.queryUserById(id);
        return user;
    }

    @GetMapping("/addUser")
    public String addUser(){
        userMapper.addUser(new User(66,"xige","666"));
        return "add_ok";
    }

    @GetMapping("/updateUserInfo")
    public String updateUserInfo(){
        userMapper.updateUserInfo(new User(66,"jingjing","666"));
        return "update_ok";
    }

    @GetMapping("/deleteUserInfo")
    public String deleteUserInfo(){
        userMapper.deleteUserInfo(66);
        return "delete_ok";
    }
    
}

至此，基本的mybatis整合就完成了。