springboot2——5.web实战

目录

 

一、静态资源导入

二、jdbcTemplate

三、Druid数据库连接池

四、整合Mybatis

---

一、静态资源导入

打开WebMvcAutoConfiguration.java源码：

可以看到第一个静态资源存放路径：

打开后面红线的源码：

还有四个地方储存静态资源：

优先级为：

二、jdbcTemplate

创建项目时选择：

即在pom.xml中添加了如下依赖：

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

本文采用mysql数据库，首先在yaml配置文件中添加：

   接下来创建controller包，JDBCcontroller.java：

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

import java.util.List;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.locks.ReentrantLock;
import java.util.concurrent.locks.ReentrantReadWriteLock;

@RestController
public class JDBCcontroller {
    @Autowired
    JdbcTemplate jdbcTemplate;
    @GetMapping("/query")
    public List<Map<String, Object>>  userList() {
        String sql ="select * from user";
        List<Map<String, Object>> users = jdbcTemplate.queryForList(sql);
        return users;
    }
    //增
    @GetMapping("/add")
    public String addUser() {
        String sql = "insert into springboot.user(id,name,pwd) values (4,'gpl','45678')";
        jdbcTemplate.update(sql);//自动提交事务
        return "添加成功";
    }

    //删
    @GetMapping("/delete/{id}")
    public String deleteUser(@PathVariable("id") int id) {
        String sql = "delete from springboot.user where id=?";
        jdbcTemplate.update(sql, id);//自动提交事务
        return "删除成功";
    }

    //改
    @GetMapping("/change/{id}")
    public String updateUser(@PathVariable("id") int id) {
        String sql = "update springboot.user set name=?,pwd=? where id=" + id;
        Object[] objects = new Object[2];
        objects[0] = "zml";
        objects[1] = "1213353";
        jdbcTemplate.update(sql, objects);//自动提交事务
        return "修改成功";
    }

}

java默认采用hariki数据库连接池。

JdbcTemplate类（Spring对JDBC的封装）：包装了所有CURD方法，并且已经放在了容器中，直接注入即可使用，比如：

· execute方法：可以用于执行任何SQL语句，一般用于执行DDL语句；
· update方法及batchUpdate方法：update方法用于执行新增、修改、删除等语句；batchUpdate方法用于执行批处理相关语句；
· query方法及queryForXXX方法：用于执行查询相关语句；
· call方法：用于执行存储过程、函数相关语句；

举例：

三、Druid数据库连接池

pom中加入依赖：

 配置文件：添加type字段，默认是hikari

添加数据源属性：

#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:日志记录(需要导入log4j依赖)
    # wall:防御sql注入
    filters: stat,wall,log4j
    maxPoolPreparedStatementPerConnectionSize: 20
    useGlobalDataSourceStat: true
    connectionProperties: druid.stat.mergeSql=true;druid.stat.slowSqlMillis=500

由于用到了log4j，导入依赖：

 

 创建config包，添加DruidConfig文件：

package com.chen.config;


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

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

@Configuration
public class DruidConfig {
    @ConfigurationProperties(prefix = "spring.datasource")
    //将全局配置文件中前缀为spring.datasource的属性值注入到 com.alibaba.druid.pool.DruidDataSource 的同名参数中
    @Bean //将自定义的 Druid数据源添加到容器中，不再让 Spring Boot 自动创建
    public DataSource druidDataSource() {
        return new DruidDataSource();
    }
    //配置Druid监控管理后台的Servlet；
    //注册到bean中
    @Bean
    public ServletRegistrationBean statViewServlet() {
        //创建一个servlet,并定义请求路径
        ServletRegistrationBean<StatViewServlet> servlet = new ServletRegistrationBean<>(new StatViewServlet(), "/druid/*");
        //初始化参数设置:后台登录的账号密码、允许访问者
        HashMap<String, String> initParameters = new HashMap<>();
        initParameters.put("loginUsername", "admin");
        //key名固定,这些参数可以在StatViewServlet的父类ResourceServlet中找到
        initParameters.put("loginPassword", "123456");
        //key名固定,这些参数可以在StatViewServlet的父类ResourceServlet中找到
        initParameters.put("allow", "localhost");
        //设置允许访问的人:这里表示只有本机可以访问(后面参数为空则所有人都可以访问)
        //设置初始化参数
        servlet.setInitParameters(initParameters);
        //返回servlet
        return servlet;
    }

}

 运行打开localhost:8080/druid，得到：

即可进行实时监控。

四、整合Mybatis

1. Mybatis目的是：

        原来使用JDBC操作数据库，需要手动的写代码去注册驱动、获取connection、获取statement等等，现在Mybaits帮助我们把这些事情做了，我们只需要关注我们的业务sql即可。MyBatis 是一款优秀的持久层框架，它支持定制化 SQL、存储过程以及高级映射。MyBatis 避免了几乎所有的 JDBC 代码和手动设置参数以及获取结果集。MyBatis可以使用简单的 XML 或注解来配置和映射原生类型、接口和 Java 的 POJO（Plain Old Java Objects，普通老式 Java 对象）为数据库中的记录。

2. 如何使用？

xml：

        每一个表所要用到的SQL对应一个xml文件，xml文件对应到一个java的接口，xml中根据mybatis的标签来写不同类型的sql，返回的格式可以用实体、字符串、列表来接收。每一个sql对应到该xml所对应接口中的一个方法。在进行sql查询时调用方法即可。

3. 举例：

1）文件结构如下：

添加依赖：

<!-- 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.2.0</version>
		</dependency>
<dependency>
			<groupId>org.projectlombok</groupId>
			<artifactId>lombok</artifactId>
			<version>1.18.20</version>
			<scope>provided</scope>
		</dependency>
<dependency>
			<groupId>mysql</groupId>
			<artifactId>mysql-connector-java</artifactId>
			<scope>runtime</scope>
		</dependency>

2）UserMapper.java:编写接口。

        回顾：接口中的方法为

public interface <接口名称>{
		public static final<成员变量>；
		public abstract <返回值> <方法名>(<方法参数列表>);
	}

        接口中的方法一定是public abstract的，因为所有实现指定接口的类都必须重写并实现该接口的所有方法。

        接口中的成员变量必须是 public static final的：

        首先static修饰变量为静态变量，静态变量和非静态变量的区别是：静态变量被所有的对象所共享，在内存中只有一个副本，它当且仅当在类初次加载时会被初始化。而非静态变量是对象所拥有的，在创建对象的时候被初始化，存在多个副本，各个对象拥有的副本互不影响。因为一个方法可能实现了多个接口，如若不是static的可能出现多个同名变量。

        其次final：

        一个final变量，如果是基本数据类型（①整数类型：long、int、short、byte②浮点类型：float、double③字符类型：char④布尔类型：boolean）的变量，则其数值一旦在初始化之后便不能更改；如果是引用类型的变量（类、 接口类型、 数组类型、 枚举类型、 注解类型、 字符串型例如，String类型就是引用类型。简单来说，所有的非基本数据类型都是引用数据类型），则在对其初始化之后便不能再让其指向另一个对象。

package com.chen.mapper;
import com.chen.pojo.User;
import org.apache.ibatis.annotations.Mapper;
import org.springframework.stereotype.Repository;
import java.util.List;
@Mapper
@Repository
public interface UserMapper {
    List<User> queryUserList();
    User queryUserById(int id);
    int addUser(User user);
    int updateUser(User user);
    int deleteUser(int id);
}

注解解释为：

@Mapper：从mybatis3.4.0开始加入了@Mapper注解，可以给mapper接口自动生成一个实现类，让spring对mapper接口的bean进行管理。

@Repository：用于将数据访问层 (DAO 层 ) 的类标识为 Spring Bean。

@Component 是一个泛化的概念，仅仅表示一个组件 (Bean) ，可以作用在任何层次。

@Service 通常作用在业务层，但是目前该功能与 @Component 相同。

@Constroller 通常作用在控制层，但是目前该功能与 @Component 相同。

 3）mapper.xml：对应上面的接口

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper
        PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.chen.mapper.UserMapper">
    <select id="queryUserList" resultType="user">
        select * from user
    </select>

    <select id="queryUserByID" resultType="user">
        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="updateUser" parameterType="user">
        update user set name=#{name},pwd=#{pwd} where id=#{id}
    </update>

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

注意：namespace中必须标注对应的接口，编写对应的方法。

4）controller：控制层

package com.chen.controller;

import com.chen.mapper.UserMapper;
import com.chen.pojo.User;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

import java.util.List;

@RestController
public class UserController {
    @Autowired
    private UserMapper userMapper;
    @GetMapping("/queryUserList")
    public List<User> queryUserList() {
        List<User> users = userMapper.queryUserList();
        return users;
    }
    @GetMapping("/queryUserByID")
    public User queryUserByID() {
        User user = userMapper.queryUserById(2);
        return user;
    }
    @GetMapping("/addUser")
    public String addUser() {
        userMapper.addUser(new User(4, "zml", "45632"));
        return "增加用户完毕";
    }
    @GetMapping("/updateUser")
    public String updateUser() {
        userMapper.updateUser(new User(4, "zml", "678910"));
        return "修改用户完毕";
    }
    @GetMapping("/deleteUser")
    public String deleteUser() {
        userMapper.deleteUser(4);
        return "删除用户完毕";
    }
}

 @AutoWired：spring可以自动帮你把bean里面引用的对象的setter/getter方法省略，它会自动帮你set/get

五、总结

1. JDBC(Java Data Base Connection,java数据库连接)是一种用于执行SQL语句的Java API,可以为多种关系数据库提供统一访问,它由一组用Java语言编写的类和接口组成.JDBC提供了一种基准,据此可以构建更高级的工具和接口,使数据库开发人员能够编写数据库应用程序

• 优点：运行期：快捷、高效
• 缺点：编辑器：代码量大、繁琐异常处理、不支持数据库跨平台

2. JdbcTemplate针对数据查询提供了多个重载的模板方法,你可以根据需要选用不同的模板方法.如果你的查询很简单，仅仅是传入相应SQL或者相关参数，然后取得一个单一的结果，那么你可以选择如下一组便利的模板方法

• 优点：运行期：高效、内嵌Spring框架中、支持基于AOP的声明式事务
• 缺点：必须于Spring框架结合在一起使用、不支持数据库跨平台、默认没有缓存

3. MyBatis 主要完成两件事情：

1. 根据JDBC 规范建立与数据库的连接
2. 通过Annotaion/XML+JAVA反射技术，实现 Java 对象与关系数据库之间相互转化

MyBatis优缺点如下:

• 优点: 高效、支持动态、复杂的SQL构建, 支持与Spring整合和AOP事务、结果集做了轻量级Mapper封装、支持缓存
• 缺点：不支持数据库跨平台, 还是需要自己写SQL语句