springboot整合mybatis，mybatisplus，jpa，druid数据源，jsp模版引擎

最新推荐文章于 2024-05-09 16:09:02 发布

代码小周

最新推荐文章于 2024-05-09 16:09:02 发布

阅读量188

点赞数

文章标签： java java-rabbitmq spring boot spring mybatis 后端 maven

本文链接：https://blog.csdn.net/hhahahhahahhha/article/details/134043768

版权

1springboot整合jsp模版引擎

创建springboot工程选择几个常见的的依赖进行，例如：lombook和spring web的依赖等，

因为jsp没有集成在srpingboot工程中所以在springboot工程中的pom文件中导入以下jsp依赖：

<dependency>
            <groupId>org.apache.tomcat.embed</groupId>
            <artifactId>tomcat-embed-jasper</artifactId>
            <scope>provided</scope>
        </dependency>

然后再点击project Structure

点击modules，在上面加入web模块，然后项目工程的目录会出现web文件夹，在web文件中创建WEB-INF/view,然后jsp文件就可以放在此文件下。

在yml文件中配置jsp模版的默认访问路径：

spring:
  mvc:
    view:
      prefix: /WEB-INF/view/
      suffix: .jsp

因为：这个路径是写在源码上的。

2springboot整合jpa

2.1在创建springboot工程的时候选择合适的数据库驱动（这是我选择的是mysql的驱动），在选择jpa的依赖

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

2.2创建bean

package com.it.springbootrabbitmq.bean;


import lombok.*;

import javax.persistence.*;

@Getter
@Setter
@ToString
@AllArgsConstructor
@NoArgsConstructor
@Entity //告诉JPA这是一个实体类
@Table(name="role")
public class role {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    String role_id;
    @Column(name = "role_name",length = 25)
    String role_name;
    String role_description;
    String role_state;
}

这里我创建了一个role角色，对应数据库里的role角色表。注意：必须要用

@Entity //这个注解告诉JPA这是一个实体类

@table（name=“role”）告诉jpa这个实体类对应数据库的那张表

@id和@GeneratedValue(strategy = GenerationType.IDENTITY)告诉jpa表的主键和主键的数据类型

@colum就是数据库对应的字段，当然字段名称一样不需要写。

2.3创建dao接口

package com.it.springbootrabbitmq.ee;

import com.it.springbootrabbitmq.bean.role;
import org.springframework.data.jpa.repository.JpaRepository;

public interface roleRepository extends JpaRepository<role,String> {
}

接口继承JpaRepository<role,String>，后面的是bean名和主键数据类型。后面调用这个接口进行，里面定义了单表的一些列操作，当然你也可以在此接口定义一些自己的方法。

这里就不在解释了。

3springboot整合druid数据源

3.1导入druid数据源依赖

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

3.2yml文件配置相关参数（包括数据库连接的参数和druid自身的参数）

spring:
  datasource:
    username: root
    password: 123456
    url: jdbc:mysql://localhost:3306/xianmu?useSSL=false
    driver-class-name: com.mysql.jdbc.Driver
    type: com.alibaba.druid.pool.DruidDataSource #切换数据源
    filters: stat,wall,log4j2



    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

    logging:
      level:
        com.alibaba.druid.filter.logging.Slf4jLogFilter: info

其中type定义了数据源的类型，type上面的是mysql数据库连接信息，type下面的是druid数据源的相关信息，例如：连接处的大小等。

logging:
  level:
    com.alibaba.druid.filter.logging.Slf4jLogFilter: info

这个是进行数据查找时打印执行的sql语句。

3.3配置druid的配置类

package org.example.springbootmybatis.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.sql.DataSource;
import java.util.Arrays;
import java.util.HashMap;
import java.util.Map;

@Configuration
public class druidconfig {


    @ConfigurationProperties(prefix = "spring.datasource")
    @Bean
    public DataSource druid(){
        return new DruidDataSource();
    }

    //配合druid的监控

    /**
     * 监控地址：http://localhost:8080/druid/login.html
     * 监控请求：http://localhost:8080/query
     * @return
     */
    //1、配置一个管理后台的servlet
    @Bean
    public ServletRegistrationBean statViewServlet(){
        ServletRegistrationBean bean= new ServletRegistrationBean(new StatViewServlet(),"/druid/*");
        Map<String,String> map=new HashMap<>();
        map.put("loginUsername","admin");
        map.put("loginPassword","123456");
        map.put("allow","localhost");//允许本机访问
        map.put("deny","192.168.122.133");//拒绝访问
        bean.setInitParameters(map);
        return bean;
    }
    //2、配置一个监控的filter
    @Bean
    public FilterRegistrationBean webStatFilter(){

        FilterRegistrationBean bean= new FilterRegistrationBean();
        bean.setFilter(new WebStatFilter());
        Map<String,String> map=new HashMap<>();
        map.put("exclusions","*.js,*.css,/druid/*");
        bean.setInitParameters(map);

        bean.setUrlPatterns(Arrays.asList("/*"));

        return bean;
    }


}

@ConfigurationProperties(prefix = "spring.datasource")
@Bean
public DataSource druid(){
    return new DruidDataSource();
}

第一个注解是关键，好耍druid使用那些数据。连接数据库。

下面俩个配置，主要是提供一个网页，里面有一些数据库的相关信息。

4springboot整合mybatis

4.1mybatis介绍

MyBatis（也被称为iBatis）是一个开源的持久层框架，用于将数据库操作与应用程序的业务逻辑分离。它提供了一种简单且灵活的方式来映射数据库表和SQL查询结果到Java对象。

MyBatis 的主要目标是通过使用简单的 XML 或注解配置来实现对数据库的访问，同时提供了强大的动态 SQL 语句的构建能力。它支持多种数据库，包括关系型数据库（如MySQL、Oracle、PostgreSQL等）和非关系型数据库（如MongoDB）。

使用 MyBatis，你可以通过编写 SQL 映射文件或者注解来定义数据库操作，包括插入、更新、删除和查询等。MyBatis 将这些操作与 Java 对象进行映射，使得数据的读写操作变得更加简洁和易于维护。

MyBatis 的核心原理是基于 SQL 映射文件或注解中的配置信息，将 SQL 语句与 Java 方法进行绑定，并通过 JDBC 执行相应的数据库操作。它提供了丰富的功能，如参数映射、结果集映射、动态 SQL、事务管理等，以满足不同场景下的需求。

总结起来，MyBatis 是一个轻量级且易于学习和使用的持久层框架，它通过将数据库操作与应用程序解耦，提供了一种灵活且高效的方式来访问和操作数据库。

4.2导入依赖到pom文件

当然也可以在创建springboot工程的时候选择spring ——mybatis的选项，这样自动导入，如果没有的话要单独导入：

<dependency>
            <groupId>org.mybatis.spring.boot</groupId>
            <artifactId>mybatis-spring-boot-starter-test</artifactId>
            <version>2.3.1</version>
            <scope>test</scope>
        </dependency>

4.3如果有数据源的话要配置mybatisconfig

package org.example.springbootmybatis.config;

import org.apache.ibatis.session.SqlSessionFactory;
import org.mybatis.spring.SqlSessionFactoryBean;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

import javax.sql.DataSource;

@Configuration
public class mybaticeconfig {

    @Autowired
    private DataSource dataSource;

    @Bean
    public SqlSessionFactory sqlSessionFactory() throws Exception {
        SqlSessionFactoryBean sessionFactory = new SqlSessionFactoryBean();
        sessionFactory.setDataSource(dataSource);
        return sessionFactory.getObject();
    }
}

如果没有的话不需要。

4.4创建mapper接口和xml文件（不使用xml文件可以使用注解）

package org.example.springbootmybatis.mapper;


import org.apache.ibatis.annotations.Mapper;
import org.apache.ibatis.annotations.Select;
import org.example.springbootmybatis.bean.Student;

import java.util.List;

public interface studentMapepr {

 @Select("select * from role")
    public List<Student> fandall();
}

当然要开启mapper代理:两种方法：

1.在mapper接口上使用@mapper注解，表示这是个mapper代理接口

2.在启动类上使用

@MapperScan(basePackages = "org.example.springbootmybatis.mapper")

扫描mapper接口所以得包。

在接口中写相应的方法就行。可以使用注解，也可以写xml文件，但是必须放在根目录下的mapper中，当然也再yml文件中更改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="org.example.springbootmybatis.mapper.studentMapepr">
    <select id="fandall"  resultType="org.example.springbootmybatis.bean.Student">
        select * from role
    </select>
</mapper>

最后调用这个接口就行。

5.springboot整合mybatisplus

5.1导入mybatisplus的依赖

<dependency>
            <groupId>com.baomidou</groupId>
            <artifactId>mybatis-plus-boot-starter</artifactId>
            <version>3.5.3.2</version>
        </dependency>

        <dependency>
            <groupId>com.baomidou</groupId>
            <artifactId>mybatis-plus-generator</artifactId>
            <version>3.5.3.2</version>
        </dependency>

5.2如果要做分页操作配置mybatisplusconfig配置类

package com.it.springbootmybaticeplus.config;

import com.baomidou.mybatisplus.annotation.DbType;
import com.baomidou.mybatisplus.extension.plugins.MybatisPlusInterceptor;
import com.baomidou.mybatisplus.extension.plugins.inner.PaginationInnerInterceptor;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration
public class mybaticeplusconfig {
    @Bean
    public MybatisPlusInterceptor mybatisPlusInterceptor() {
        MybatisPlusInterceptor interceptor = new MybatisPlusInterceptor();
        interceptor.addInnerInterceptor(new PaginationInnerInterceptor(DbType.MYSQL));
        return interceptor;
    }

}

5.3在yml文件中添加数据库连接信息

spring:
  datasource:
    driver-class-name: com.mysql.jdbc.Driver
    url: jdbc:mysql://localhost:3306/xuexi?useSSL=false&characterEncoding=utf8
    username: root
    password: 123456
      #sql:
      #init:
      #schema-locations: classpath:sql/data.sql  # DDL???resources/sql/schema.sql
      #data-locations: classpath:sql/data.sql  # sql???resources/sql/data.sql
    #mode: always


    #type: com.alibaba.druid.pool.DruidDataSource #切换数据源
    #filters: stat,wall,log4j2



    #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

    #logging:
      #level:
         # com.alibaba.druid.filter.logging.Slf4jLogFilter: info


#  security:
#    user:
#      name: zhou
#      password: 123456


mybatis-plus:
  configuration:
    log-impl: org.apache.ibatis.logging.stdout.StdOutImpl
    map-underscore-to-camel-case: false
  # 如果是放在src/main/java目录下 classpath:/com/*/*/mapper/*Mapper.xml
  # 如果是放在resource目录 classpath:/mapper/**.xml
  mapper-locations: classpath:/mapper/**.xml

configuration:
  log-impl: org.apache.ibatis.logging.stdout.StdOutImpl
  map-underscore-to-camel-case: false

这个是不要对我们的表字段进行修改。关闭驼峰命名等。

mapper-locations: classpath:/mapper/**.xml

这个是mapper.xml文件放的位置。前面的我不一一介绍了

5.4mapper接口和xml文件等

这个内容和mybatis大致一样唯一不一样的是创建接口的时候要继承一个类

BaseMapper<role>接收的是表名也就是bean。

package com.it.springbootmybaticeplus.mapper;

import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import com.baomidou.mybatisplus.core.toolkit.Constants;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.it.springbootmybaticeplus.bean.role;
import org.apache.ibatis.annotations.Mapper;
import org.apache.ibatis.annotations.Param;
import org.apache.ibatis.annotations.Select;

@Mapper
public interface roleMapper extends BaseMapper<role> {

    @Select("select * from role ${ew.customSqlSegment}")
    public Page<role> selectByPrimaryKey(Page<role> page,
                                         @Param(Constants.WRAPPER) QueryWrapper<role> queryWrapper);




   public Page<role> selectPage(@Param("page") Page<role> page,
                             @Param("role_id") String role_id);


}

5.5相关注解解释

使用@Param注解

当以下面的方式进行写SQL语句时：

@Select("select column from table where userid = #{userid} ")

public int selectColumn(int userid);

当你使用了使用@Param注解来声明参数时，如果使用 #{} 或 ${} 的方式都可以。

@Select("select column from table where userid = ${userid} ")

public int selectColumn(@Param("userid") int userid);

当你不使用@Param注解来声明参数时，必须使用使用 #{}方式。如果使用 ${} 的方式，会报错。

@Select("select column from table where userid = ${userid} ")

public int selectColumn(@Param("userid") int userid);

2）不使用@Param注解

不使用@Param注解时，参数只能有一个，并且是Javabean。在SQL语句里可以引用JavaBean的属性，而且只能引用JavaBean的属性。

// 这里id是user的属性

@Select("SELECT * from Table where id = ${id}")

Enchashment selectUserById(User user);

5.6Wrapper传参+注解SQL

5.6.1在接口中创建自定义方法和sql

public interface StudentMapper extends BaseMapper<Student> {
    @Select("select * from student ${ew.customSqlSegment}")
    public Page<Student> selectByPrimaryKey(Page<Student> page, 
@Param(Constants.WRAPPER) QueryWrapper<Student> queryWrapper);

}

创建测试类：

@RequestMapping("/findStudentByWrapper")
@ResponseBody
public Page<Student> findStudentByWrapper(){
    //创建Wrapper对象
    QueryWrapper<Student> wrapper = new QueryWrapper<>();
    //设置查询条件
    wrapper.eq("stu_id", "1001")
            .like("stu_name", "晓春");
    //设置排序条件-可选条件
    //wrapper.orderByAsc("stu_id");
    //设置分页参数-可选条件
    Page<Student> resultPage = new Page<>(1, 10);
    Page<Student> list=studentMapper.selectByPrimaryKey(resultPage,wrapper);
    return list;
}

还有一种方式（不常用）：

@RequestMapping("/findStudentByWrapper")
@ResponseBody
public IPage<Student> findStudentByWrapper(){
    /*//创建Wrapper对象
    QueryWrapper<Student> wrapper = new QueryWrapper<>();
    //设置查询条件
    wrapper.eq("stu_id", "1001")
            .like("stu_name", "晓春");
    //设置排序条件-可选条件
    //wrapper.orderByAsc("stu_id");
    //设置分页参数-可选条件
    Page<Student> resultPage = new Page<>(1, 10);
    Page<Student> list=studentMapper.selectByPrimaryKey(resultPage,wrapper);*/

    //分页查询方式2
    IPage<Student> page = new Page<>(1, 10); // 分页查询
    LambdaQueryWrapper<Student> qw = new LambdaQueryWrapper<Student>()
            .like(Student::getStu_name, "晓春") // 姓名
            .eq(Student::getStu_id, "1001"); // id
    //selectPage是BaseMapper自带方法
    IPage<Student> userPage = studentMapper.selectPage(page, qw);
    return userPage;

好了最后几天就到这里，明天继续介绍springboot整合security和rambbittmq。祝大家生活愉快！！！！

代码小周

关注

0
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
springboot整合mybatis，mybatisplus，jpa，druid数据源，jsp模版引擎

springboot整合操作等 MyBatis（也被称为iBatis）是一个开源的持久层框架，用于将数据库操作与应用程序的业务逻辑分离。它提供了一种简单且灵活的方式来映射数据库表和SQL查询结果到Java对象。MyBatis 的主要目标是通过使用简单的 XML 或注解配置来实现对数据库的访问，同时提供了强大的动态 SQL 语句的构建能力。它支持多种数据库，包括关系型数据库（如MySQL、Oracle、PostgreSQL等）和非关系型数据库（如MongoDB）。
复制链接

扫一扫