我和springboot的第一次相遇

最新推荐文章于 2022-10-21 13:52:53 发布

莫等闲，白了少年头

最新推荐文章于 2022-10-21 13:52:53 发布

阅读量217

点赞数 1

分类专栏： Java学习笔记文章标签： spring boot mysql mybatis spring java

本文链接：https://blog.csdn.net/lbj_155207/article/details/110458267

版权

Java学习笔记专栏收录该内容

32 篇文章 0 订阅

订阅专栏

SpringBoot初识

一、基础

1、概念

springboot是spring快速开发脚手架，通过约定大于配置的方式，快速构建和启动spring项目

2、特点

快速开发spring应用的框架
内嵌tomcat和jetty容器，不需要单独安装容器，jar包直接发布一个web应用
简化maven配置，parent这种方式，一站式引入需要的各种依赖
基于注解的零配置思想
和各种流行框架，spring web mvc，mybatis，spring cloud无缝整合

3、基础配置

<?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.java</groupId>
    <artifactId>Empty_Demo</artifactId>
    <version>1.0-SNAPSHOT</version>


    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.0.0.RELEASE</version>
    </parent>
    <properties>
        <java.version>1.11</java.version>
    </properties>
    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
    </dependencies>
</project>

4、全注解配置

数据库连接举例说明：

方法一：

依赖：
<dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>druid</artifactId>
            <version>1.1.10</version>
        </dependency>

//数据源：
jdbc.driverClassName=com.mysql.cj.jdbc.Drive 
jdbc.url=jdbc:mysql://127.0.0.1:3306/test
jdbc.username=root
jdbc.password=123456

//代码
package com.java.config;

import com.alibaba.druid.pool.DruidDataSource;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.PropertySource;

import javax.sql.DataSource;

@Configuration
@PropertySource("classpath:jdbc.properties")
public class JdbcConfig {

    @Value("${jdbc.url}")
    String url;
    @Value("${jdbc.driverClassName}")
    String driverClassName;
    @Value("${jdbc.username}")
    String username;
    @Value("${jdbc.password}")
    String password;

    @Bean
    public DataSource dataSource(){
        DruidDataSource dataSource = new DruidDataSource();
        dataSource.setDriverClassName(driverClassName);
        dataSource.setUrl(url);
        dataSource.setUsername(username);
        dataSource.setPassword(password);
        return  dataSource;
    }
}

package com.java.controller;

import com.java.config.JdbcConfig;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

import javax.sql.DataSource;

@RestController
public class Controller {
    @Autowired
    private DataSource dataSource;

    @GetMapping("/hello")
    public  String hello(){
        return "Hello World...."+dataSource;
    }
}

说明：

@Configuration ：声明我们 JdbcConfig 是一个配置类
@PropertySource ：指定属性文件的路径是: classpath:jdbc.properties
通过 @Value 为属性注入值
通过@Bean将 dataSource() 方法声明为一个注册Bean的方法，Spring会自动调用该方法，将方法的返回值加入Spring容器中。默认的对象名id=方法名，可以通过@Bean(“自定义名字”)，来指定新的对象名
在任意位置通过 @Autowired 注入DataSource。

方法二：

package com.java.config;

import com.alibaba.druid.pool.DruidDataSource;
import org.springframework.boot.context.properties.EnableConfigurationProperties;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

import javax.sql.DataSource;

@Configuration
@EnableConfigurationProperties(JdbcProperties.class)
public class JdbcConfig1 {



    @Bean
    public DataSource dataSource(JdbcProperties jdbcProperties){
        DruidDataSource dataSource = new DruidDataSource();
        dataSource.setDriverClassName(jdbcProperties.getDriverClassName());
        dataSource.setUrl(jdbcProperties.getUrl());
        dataSource.setUsername(jdbcProperties.getUsername());
        dataSource.setPassword(jdbcProperties.getPassword());
        return  dataSource;
    }
}

package com.java.config;

import org.springframework.boot.context.properties.ConfigurationProperties;

@ConfigurationProperties(prefix = "jdbc")
public class JdbcProperties {
    private String url;
    private String driverClassName;
    private String username;
    private String password;

    public String getUrl() {
        return url;
    }

    public void setUrl(String url) {
        this.url = url;
    }

    public String getDriverClassName() {
        return driverClassName;
    }

    public void setDriverClassName(String driverClassName) {
        this.driverClassName = driverClassName;
    }

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

方法三：

	 @Bean // 声明要注入的属性前缀，SpringBoot会自动把相关属性通过set方法注入到DataSource中
     @ConfigurationProperties(prefix = "jdbc")
     public DataSource dataSource() {
        DruidDataSource dataSource = new DruidDataSource(); 
         return dataSource;
    }

5、配置原理

自动配置：

主要是通过启动器的@SpringBootApplication注解启动，然后找到自动配置类

在这里插入图片描述

默认配置原理：

@EnableAutoConfifiguration会开启SpringBoot的自动配置，并且根据你引入的依赖来生效对应的默认配置， springboot如何做到的？

其实在我们的项目中，已经引入了一个依赖：spring-boot-autoconfifigure，其中定义了大量自动配置类：

在这里插入图片描述

@Configuration ：声明这个类是一个配置类
@ConditionalOnClass({ Servlet.class, DispatcherServlet.class, WebMvcConfigurer.class })：这里的条件是OnClass，也就是满足以下类存在：Servlet、DispatcherServlet、WebMvcConfifigurer，其中 Servlet只要引入了tomcat依赖自然会有，后两个需要引入SpringMVC才会有。这里就是判断你是否引入了相关依赖，引入依赖后该条件成立，当前类的配置才会生效！
@ConditionalOnMissingBean(WebMvcConfigurationSupport.class) ：这个条件与上面不同，OnMissingBean，是说环境中没有指定的Bean这个才生效。其实这就是自定义配置的入口，也就是说，如果我们自己配置了一个WebMVCConfifigurationSupport的类，那么这个默认配置就会失效！

二、整合

A、MVC

1、修改端口

在application.properties文件中设置：

#设置端口号
server.port=8081

2、访问静态资源

将静态资源放入以下路径中即可：
在这里插入图片描述

习惯会把静态资源放在 classpath:/static/ 目录下。

3、创建拦截器

创建一个LoginInterceptor类

package com.java.interceptor;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.web.servlet.HandlerInterceptor;
import org.springframework.web.servlet.ModelAndView;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;


public class LoginInterceptor implements HandlerInterceptor {
    private Logger logger = LoggerFactory.getLogger(LoginInterceptor.class);

    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) {
        logger.debug("处理器执行前执行!");
        return true;
    }

    @Override
    public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView) {
        logger.debug("处理器执行后执行!");
    }

    @Override
    public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) {
        logger.debug("跳转后执行!");
    }
}

注册拦截器：

package com.java.config;

import com.java.interceptor.LoginInterceptor;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.web.servlet.config.annotation.InterceptorRegistry;
import org.springframework.web.servlet.config.annotation.WebMvcConfigurer;

@Configuration
public class MvcConfig implements WebMvcConfigurer {
    /*** 通过@Bean注解，将我们定义的拦截器注册到Spring容器 * @return */
    @Bean
    public LoginInterceptor loginInterceptor() {
        return new LoginInterceptor();
    }

    /*** 重写接口中的addInterceptors方法，添加自定义拦截器 * @param registry */
    @Override
    public void addInterceptors(InterceptorRegistry registry) {
        // 通过registry来注册拦截器，通过addPathPatterns来添加拦截路径
        registry.addInterceptor(this.loginInterceptor()).addPathPatterns("/**");
    }
}

注意：springboot默认的日志级别是info。因此需要在application.properties文件中修改日志级别

#设置日志级别
logging.level.com.java = debug

B、JDBC

1.导入依赖:

 <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-jdbc</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
        </dependency>
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>8.0.21</version>
        </dependency>

2.properties文件配置：

# 连接四大参数 
#mysql 8版本
spring.datasource.url=jdbc:mysql://localhost:3306/springboot?serverTimezone=Asia/Shanghai&zeroDateTimeBehavior=convertToNull
spring.datasource.username=root
spring.datasource.password=123456
# 可省略，SpringBoot自动推断
spring.datasource.driverClassName=com.mysql.cj.jdbc.Driver
spring.datasource.hikari.idle-timeout=60000
spring.datasource.hikari.maximum-pool-size=30
spring.datasource.hikari.minimum-idle=10

3.实体类:

4.创建dao

package com.java.dao;

import com.java.bean.User;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.jdbc.core.BeanPropertyRowMapper;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.stereotype.Repository;

import java.util.List;

@Repository
public class UserDao {

    @Autowired
    private JdbcTemplate jdbcTemplate;

    public List<User> findAll(){
        //BeanPropertyRowMapper:可以把同名字段赋值给类的属性
        return jdbcTemplate.query("select * from tb_user",new BeanPropertyRowMapper<>(User.class));
    }
}

5.使用测试类进行测试：

package com.java.dao;

import junit.framework.TestCase;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.context.junit4.SpringRunner;


@RunWith(SpringRunner.class)
@SpringBootTest
public class UserDaoTest extends TestCase {

    @Autowired
    private  UserDao userDao;
    
    @Test
    public void testFindAll() {
        userDao.findAll().forEach(user -> {
            System.out.println(user);
        });
    }
}

C、Mybatis

<dependency>
            <groupId>org.mybatis.spring.boot</groupId>
            <artifactId>mybatis-spring-boot-starter</artifactId>
            <version>1.3.0</version>
        </dependency>

#mybatis 别名扫描
mybatis.type-aliases-package=com.java.bean
  # mapper.xml文件位置,如果没有映射文件，请注释掉
 mybatis.mapper-locations=classpath:mappers/*.xml

<!--mapper文件-->
<?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.lxs.demo.dao.UserDao">
    <select id="findAll" resultType="user"> select * from tb_user </select>
</mapper>

1、通用mapper

`通用mybatis（tk mybatis）
mybatis plus

<!--依赖-->
<!-- 通用mapper --> 
<dependency> 
    <groupId>tk.mybatis</groupId> 
    <artifactId>mapper-spring-boot-starter</artifactId> 
    <version>2.0.2</version> 
</dependency>

//实体类 
@Table(name = "tb_user")    //可以使用Table注解指定表名，也可以直接将类名和表名设置为一样
public class User implements Serializable {
    private static final long serialVersionUID = 1L;
    @Id  
    @GeneratedValue(strategy = GenerationType.IDENTITY)    //主键
    private Long id; 
    // 用户名
    private String userName; 
}

    /**
    1. 默认表名=类名，字段名=属性名 
    2. 表名可以使用 @Table(name = "tableName") 进行指定
    3. @Column(name = "fieldName") 指定 
    4. 使用 @Transient 注解表示跟字段不进行映射 不需要做任何配置就可以使用了
    */
//接口
@Mapper    //包必须是tk.mybatis下的Mapper
public interface UserMapper extends tk.mybatis.mapper.common.Mapper<User>{ 
    public List<User> findByUser(User user);
}

复杂的查询时可以自定义映射文件：

<?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.lxs.demo.dao.UserMapper">
    <select id="findByUser" resultType="user"> 
        SELECT *FROM tb_user
        <where> 
            <if test="name != null"> 
                name like '%${name}%'
            </if>
            <if test="note != null"> 
                and note like '%${note}%' 
            </if> 
        </where>
    </select>
</mapper>

//测试
    @SpringBootTest
public class UserDaoTest {
    @Autowired 
    private UserDao userDao; 
    @Test 
    public void testFindByUser() {
        User condition = new User();
        condition.setName("a");
        List<User> list = userMapper.findByUser(condition);
        for (User user : list) {
            System.out.println(user);
        }
    }
    @Test 
    public void testFindAll() {
        List<User> list = userDao.selectAll(); 
        for (User user : list) { 
            System.out.println(user); 
        } 
    }
    @Test 
    public void testFindById() { 
        User user = userDao.selectByPrimaryKey(4);
        System.out.println(user);
    }
    @Test 
    public void testFindByExample() {
        Example example = new Example(User.class); 
        example.createCriteria().andLike("name", "%a%"); 
        userMapper.selectByExample(example).forEach(user -> {
            System.out.println(user); 
        });
    }

注意：

Select 方法： List select(T record); 说明：根据实体中的属性值进行查询，查询条件使用等号

方法： T selectByPrimaryKey(Object key); 说明：根据主键字段进行查询，方法参数必须包含完整的主键属性，查询条件使用等号

方法： List selectAll(); 说明：查询全部结果，select(null)方法能达到同样的效果

方法： T selectOne(T record); 说明：根据实体中的属性进行查询，只能有一个返回值，有多个结果是抛出异常，查询条件使用等号

方法： int selectCount(T record); 说明：根据实体中的属性查询总数，查询条件使用等号

Insert 方法： int insert(T record); 说明：保存一个实体，null的属性也会保存，不会使用数据库默认值

方法： int insertSelective(T record); 说明：保存一个实体，null的属性不会保存，会使用数据库默认值

Update 方法： int updateByPrimaryKey(T record); 说明：根据主键更新实体全部字段，null值会被更新

方法： int updateByPrimaryKeySelective(T record); 说明：根据主键更新属性不为null的值

Delete 方法： int delete(T record); 说明：根据实体属性作为条件进行删除，查询条件使用等号

方法： int deleteByPrimaryKey(Object key); 说明：根据主键字段进行删除，方法参数必须包含完整的主键属性

Example****方法 方法： List selectByExample(Object example); 说明：根据Example条件进行查询重点：这个查询支持通过 Example 类指定查询列，通过 selectProperties 方法指定查询列

方法： int selectCountByExample(Object example); 说明：根据Example条件进行查询总数

方法： int updateByExample(@Param(“record”) T record, @Param(“example”) Object example); 说明：根据 Example条件更新实体 record 包含的全部属性，null值会被更新

方法： int updateByExampleSelective(@Param(“record”) T record, @Param(“example”) Object example); 说明：根据Example条件更新实体 record 包含的不是null的属性值

方法： int deleteByExample(Object example); 说明：根据Example条件删除数据

2、Thymeleaf

特点：

动静结合：Thymeleaf 在有网络和无网络的环境下皆可运行，无网络显示静态内容，有网络用后台得到数据替换静态内容
与SpringBoot完美整合，springboot默认整合thymeleaf

//接口
@Service 
public class UserService {
    @Autowired 
    private UserDao userDao; 
    public List<User> queryAll() { 
        return this.userDao.selectAll();
    }
}


//controller
@Controller
public class UserController { 
    @Autowired
    private UserService userService; 
    @RequestMapping("/all") 
    public String all(Model model) {
        List<User> list = userService.findAll(); 
        model.addAttribute("users", list); 
        // 返回模板名称（就是classpath:/templates/目录下的html文件名，users.html存放在resource胡templates目录下） 
        return "users";
    } 
}

<!--引入启动器-->
<dependency> 
    <groupId>org.springframework.boot</groupId> 
    <artifactId>spring-boot-starter-thymeleaf</artifactId> 
</dependency>

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-UKSnYh0O-1606925178632)(F:\开课吧-Java\笔记\图片\第十三章\1\6.png)]

默认前缀： classpath:/templates/
默认后缀： .html

静态页面：

<!DOCTYPE html>
<html xmlns:th="http://www.thymeleaf.org">
<head>
    <meta charset="UTF-8">
    <title>首页</title>
    <style type="text/css">
        table {
            border-collapse: collapse;
            font-size: 14px;
            width: 80%;
            margin: auto
        }

        table, th, td {
            border: 1px solid darkslategray;
            padding: 10px
        }
    </style>
</head>
<body>
<div style="text-align: center">
    <span style="color: darkslategray; font-size: 30px">欢迎光临！</span>
    <hr/>
    <table class="list">
        <tr>
            <th>id</th>
            <th>姓名</th>
            <th>用户名</th>
            <th>年龄</th>
            <th>性别</th>
            <th>生日</th>
            <th>备注</th>
            <th>操作</th>
        </tr>
        <tr th:each="user, status : ${users}" th:object="${user}">
            <td th:text="${user.id}">1</td>
            <td th:text="*{name}">张三</td>
            <td th:text="*{userName}">zhangsan</td>
            <td th:text="${user.age}">20</td>
            <td th:text="${user.sex} == 1 ? '男': '女'">男</td>
            <td th:text="${#dates.format(user.birthday, 'yyyy-MM-dd')}">1980-02-30</td>
            <td th:text="${user.note}">1</td>
            <td><a th:href="@{/delete(id=${user.id}, userName=*{userName})}">删除</a> <a
                    th:href="|/update/${user.id}|">修改</a> <a th:href="'/approve/' + ${user.id}">审核</a></td>
        </tr>
    </table>
</div>
</body>
</html>

注意：

${} ：这个类似与el表达式，但其实是ognl的语法，比el表达式更加强大
th- 指令： th- 是利用了Html5中的自定义属性来实现的。如果不支持H5，可以用 data-th- 来代替
th:each ：类似于 c:foreach 遍历集合，但是语法更加简洁
th:text ：声明标签中的文本

例如 1 ，如果user.id有值，会覆盖默认的1 如果没有值，则会显示td中默认的1。这正是thymeleaf能够动静结合的原因，模板解析失败不影响页面的显示效果，因为会显示默认值！

模板缓存

# 开发阶段关闭thymeleaf的模板缓存 
spring.thymeleaf.cache=false

表达式：

变量表达式
选择或星号表达式
URL表达式

变量表达式:变量表达式即OGNL表达式或Spring EL表达式(在Spring中用来获取model attribute的数据)。
例如：		
	${session.user.name}  或者
	<h5>表达式</h5> 
	<span>${text}</span>
    <span th:text="${text}">你好 thymleaf</span>

选择(星号)表达式：选择表达式很像变量表达式，不过它们用一个预先选择的对象来代替上下文变量容器(map)来执行。
例如：	
	{customer.name}  或者
	<tr th:each="user : ${users}" th:object="${user}">
    <td th:text="${user.id}">1</td> 
    <td th:text="*{name}">张三</td>
    <td th:text="*{userName}">zhangsan</td>
 URL表达式:URL表达式指的是把一个有用的上下文或回话信息添加到URL，这个过程经常被叫做URL重写。
 例如：	
 	@{/order/list} URL还可以设置参数： @{/order/details(id=${orderId}, name=*{name})} 相对路径： @{../documents/report}
 	或者
 	<form th:action="@{/createOrder}">
    <a href="main.html" th:href="@{/main}">

url表达式：<a th:href="@{/delete(id=${user.id}, userName=*{userName})}">删除</a>
文本替换：<a th:href="|/update/${user.id}|">修改</a>
字符串拼接：<a th:href="'/approve/' + ${user.id}">审核</a>

布局：

在/resources/templates/目录下创建footer.html。

<!DOCTYPE html> 
<html xmlns:th="http://www.thymeleaf.org"> 
    <body><footer th:fragment="copy(title)">
        &copy; 2020 hahaha版权所有<br> 
        <span th:text="${title}">title footer</span> 
        </footer>
    </body> 
</html>

引入：

<h5>thymeleaf布局</h5>
<div th:insert="footer :: copy('hahaha1')"></div>
<div th:replace="footer :: copy('hahaha2')"></div> 
<div th:include="footer :: copy('hahaha3')"></div>

注意：

th:insert ：保留自己的主标签，保留th:fragment的主标签。
th:replace ：不要自己的主标签，保留th:fragment的主标签。
th:include ：保留自己的主标签，不要th:fragment的主标签。

返回的html代码：

<h5>thymeleaf布局</h5>
<div><footer> 
    &copy; 2020 hahaha版权所有<br> 
    <span>hahaha1</span>
    </footer>
</div> 
<footer> 
    &copy; 2020 hahaha版权所有<br> 
    <span>hahaha2</span>
</footer> 
<div>
    &copy; 2020 hahaha版权所有<br> 
    <span>hahaha3</span>
</div>

D、Mybatisplus

<!--pom.xml-->
<?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.java</groupId>
    <artifactId>mybatis-plus</artifactId>
    <version>1.0-SNAPSHOT</version>

    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.3.0.RELEASE</version>
        <relativePath/>
    </parent>
    <properties>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
        <java.version>1.8</java.version>
        <mybatisplus.version>3.3.2</mybatisplus.version>
        <skipTests>true</skipTests>
    </properties>
    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter</artifactId>
        </dependency>
        <dependency>
            <groupId>com.h2database</groupId>
            <artifactId>h2</artifactId>
            <scope>runtime</scope>
        </dependency>
        <dependency>
            <groupId>com.baomidou</groupId>
            <artifactId>mybatis-plus-boot-starter</artifactId>
            <version>${mybatisplus.version}</version>
        </dependency>
        <dependency>
            <groupId>org.assertj</groupId>
            <artifactId>assertj-core</artifactId>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <scope>provided</scope>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
    </dependencies>
    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>
</project>

#application.yml
#连接h2数据库
spring:
  datasource:
    driver-class-name: org.h2.Driver
    schema: classpath:db/schema-h2.sql   #建立数据表
    data: classpath:db/data-h2.sql   #插入数据
    url: jdbc:h2:mem:test
    username: root
    password: 123456
logging:
  level:
    com.java: debug

//实体类
package com.java.entity;

import com.baomidou.mybatisplus.annotation.TableName;
import lombok.Data;
import lombok.experimental.Accessors;

/**
 * @Author: 
 * @Description:
 * @Date Created in 2020-12-03 22:52
 * @Modified By:
 */
@Data
@Accessors(chain = true)
@TableName("USER2")
public class User {

    private  long id;
    private  String  name;
    private  Integer age;
    private  String email;
}

//dao层
package com.java.mapper;

import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import com.java.entity.User;

/**
 * @Author: 
 * @Description:
 * @Date Created in 2020-12-03 22:53
 * @Modified By:
 */

public interface UserMapper  extends BaseMapper<User> {

    //不用写方法，可以直接使用内置方法
}

//Application启动器
package com.java;

import org.mybatis.spring.annotation.MapperScan;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
@MapperScan("com.java.mapper")
public class Application {
    public static void main(String[] args) {
        SpringApplication.run(Application.class, args);
    }
}

//测试
package com.java.mapper;

import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.toolkit.Wrappers;
import com.java.entity.User;
import org.junit.Assert;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.context.junit4.SpringRunner;

import javax.annotation.Resource;
import java.util.List;

import static org.junit.Assert.*;

/**
 * @Author: 
 * @Description:
 * @Date Created in 2020-12-03 22:56
 * @Modified By:
 */
@RunWith(SpringRunner.class)
@SpringBootTest
public class UserMapperTest {

    @Resource
    private  UserMapper userMapper;

    @Test
    public  void  testSelect(){
        List<User> users = userMapper.selectList(null);
        users.forEach(System.out::println);

        Assert.assertEquals(25,users.size());
    }

    @Test
    public  void testDelete(){

//        //主键删除
//        userMapper.deleteById(2l);
//        userMapper.selectList(null).forEach(System.out::println);

        //批量删除 1
//        userMapper.delete(new QueryWrapper<User>().like("name","k"));
//        userMapper.selectList(null).forEach(System.out::println);
        //批量删除 2
//        userMapper.delete(Wrappers.<User>query().like("name","k"));
//        userMapper.selectList(null).forEach(System.out::println);
        //批量删除 3
        userMapper.delete(Wrappers.<User>query().lambda().like(User::getName,"k"));
        userMapper.selectList(null).forEach(System.out::println);
    }

    @Test
    public  void testUpdate(){

        //基本修改
//        userMapper.updateById(new User().setId(1l).setAge(100));
//        userMapper.selectList(null).forEach(System.out::println);
        //批量修改1
//        userMapper.update(null ,Wrappers.<User>update().set("email","123@126.com").like("name",'k'));
//        userMapper.selectList(null).forEach(System.out::println);

        //批量修改2
        userMapper.update(new User().setEmail("123@126.com"),Wrappers.<User>update().like("name",'k'));
        userMapper.selectList(null).forEach(System.out::println);
    }

    @Test
    public  void  testSelect1(){
        userMapper.selectList(new QueryWrapper<User>().select("id","name","email")).forEach(user -> {
            System.out.println(user);
        });
    }
}

常用注解：

@TableName ：实体类的类名和数据库表名不一致时
@TableId ：实体类的主键名称和表中主键名称不一致
@TableField ：实体类中的成员名称和表中字段名称不一致>

E、分页

1、内置分页

//配置文件
@Configuration
@MapperScan("com.lxs.mybatisplus.samples.crud.mapper")
public class MybatisPlusConfig {
    /*** mp分页插件 */
    @Bean
    public PaginationInterceptor paginationInterceptor() {
        // 开启 count 的 join 优化,只针对 left join !!!
        return new PaginationInterceptor().setCountSqlParser(new JsqlParserCountOptimize(true));
    }

    /**
     * 两个分页插件都配置,不会冲突
     * pagehelper的分页插件
     */
    @Bean
    public PageInterceptor pageInterceptor() {
        return new PageInterceptor();
    }
}


//测试
@Test
public void testPage() {

    //参数1：第几页
    //参数2：每页行数
    Page<User> page = new Page<>(2, 10);
    Page<User> pr = userMapper.selectPage(page, Wrappers.<User>query());
    System.out.println("总行数：" + pr.getTotal());
    System.out.println("总页数：" + pr.getPages());
    System.out.println("每页行数：" + pr.getSize());
    pr.getRecords().forEach(user -> {
        System.out.println(user);
    });
}

2、自定义xml映射文件

# 配置mybatis plus
mybatis-plus:
  type-aliases-package: com.java.entity     #别名搜索
  mapper-locations: classpath:/mapper/*.xml   #加载映射文件

package com.java.mapper;

import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.java.entity.User;
import org.apache.ibatis.annotations.Param;

import java.util.List;

/**
 * @Author: 
 * @Description:
 * @Date Created in 2020-12-03 22:53
 * @Modified By:
 */

public interface UserMapper extends BaseMapper<User> {

    //不用写方法，可以直接使用内置方法


    /*** 如果映射的接口方法有2个参数需要@Param定义参数名，定义参数名后，映射文件中使用p.属性 c.属性，具体访 问 ** @param page * @param conditioin * @return */
    public IPage<User> selectUserByPage(@Param("p") IPage<User> page, @Param("c") User conditioin);

    public List<User> selectUserByPage2(User user);

}

<!--usermaper.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.java.mapper.UserMapper">
    <sql id="selectSql"> SELECT* FROM user2 </sql>
    <select id="selectUserByPage" resultType="user">
        <include refid="selectSql"></include>
        <where>
            <if test="c.age !=null">age = #{c.age}</if>
            <if test="c.email !=null">and email like '%${c.email}%'</if>
        </where>
    </select>

    <select id="selectUserByPage2" resultType="user">
        <include refid="selectSql"></include>
        <where>
            <if test="age !=null">age = #{age}</if>
            <if test="email !=null">and email like '%${email}%'</if>
        </where>
    </select>
</mapper>

@Test
public void testXmlPage() {

    //参数1：第几页
    //参数2：每页行数
    Page<User> page = new Page<>(2, 10);

    //条件对象
    User u = new User();
    u.setAge(331);
    u.setEmail("test4");

    IPage<User> pr = userMapper.selectUserByPage(page, u);
    System.out.println("总行数：" + pr.getTotal());
    System.out.println("总页数：" + pr.getPages());
    System.out.println("每页行数：" + pr.getSize());
    pr.getRecords().forEach(user -> {
        System.out.println(user);
    });
}

3、Pagehelper

<dependency>
    <groupId>com.github.pagehelper</groupId>
    <artifactId>pagehelper</artifactId>
    <version>5.1.11</version>
</dependency>

映射文件和配置类在上面已经展示。

@Test
public void testPageHelper() {
    // pagehelper
    // PageInfo<User> page = PageHelper.startPage(1, 2).doSelectPageInfo(() -> mapper.selectList(Wrappers.<User>query()));
    PageHelper.startPage(1,2);
    // PageInfo<User> page = new PageInfo<>(mapper.selectList(Wrappers.<User>query()));
    User u = new User(); u.setAge(20);
    PageInfo<User> page = new PageInfo<User>(userMapper.selectUserByPage2(u));
    List<User> list = page.getList();
    System.out.println("总行数=" + page.getTotal()); System.out.println("当前页=" + page.getPageNum());
    System.out.println("每页行数=" + page.getPageSize());
    System.out.println("总页数=" + page.getPages());
    System.out.println("起始行数=" + page.getStartRow());
    System.out.println("是第一页=" + page.isIsFirstPage());
    System.out.println("是最后页=" + page.isIsLastPage());
    System.out.println("还有下一页=" + page.isHasNextPage());
    System.out.println("还有上一页=" + page.isHasPreviousPage());
    System.out.println("页码列表" + Arrays.toString(page.getNavigatepageNums())); }
}

莫等闲，白了少年头

关注

1
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
我和springboot的第一次相遇

SpringBoot初识一、基础1、概念springboot是spring快速开发脚手架，通过约定大于配置的方式，快速构建和启动spring项目2、特点快速开发spring应用的框架内嵌tomcat和jetty容器，不需要单独安装容器，jar包直接发布一个web应用简化maven配置，parent这种方式，一站式引入需要的各种依赖基于注解的零配置思想和各种流行框架，spring web mvc，mybatis，spring cloud无缝整合3、基础配置<?xml
复制链接

扫一扫

专栏目录