Springboot集成mybatis与jsp过程详解

目录
  • 什么是Spring Boot?
  • springboot特点
  • springboot快速搭建项目
    • 新建项目springboot_mybatis_jsp
    • 项目配置
      • 配置项目目录
      • 配置工作目录(working directory)
      • 配置pom.xml
      • 配置application.properties
    • 编写代码
      • 建表t_user
      • 编写User.java
      • 编写UserMapper.xml
      • 编写UserService.java、UserServiceImpl.java
      • 编写Controller

什么是Spring Boot?

Spring Boot是一种全新的框架(相对而言),是用来简化Spring应用的初始搭建以及开发过程。该框架使用了特定的方式来进行配置。通过这种方式Spring Boot将在蓬勃发展的快速应用开发领域(rapid application development)成为领导者。

springboot特点

  • 创建独立的Spring应用程序
  • 嵌入的Tomcat,无需部署WAR文件
  • 简化Maven配置
  • 自动配置Spring
  • 没有XML配置

springboot快速搭建项目

springboot的东西很多,其余的东西后面有机会再做补充吧。

今天主要以标题springboot集成mybatis与jsp为例演示springboot快速搭建项目

新建项目springboot_mybatis_jsp

这里我们目前只选一个web依赖,剩下的我们需要的时候再手动添加;

springboot的版本我们选择2.4.5,后面我们手动改成2.2.5.RELEASE。

最后我们点击Finish。至此我们项目的初始化就完成了。

项目配置

配置项目目录

mapper目录的添加要注意是com/christy/mapper,这里不要搞错了

配置工作目录(working directory)

这一步一定要做,否则无法访问到项目的jsp页面

第一步中点击下拉三角形选择Edit Configurations

第四步直接双击完后记得点击Apply->OK

配置pom.xml

我们说了要实现springboot集成mybatis和jsp,所以首先要假如他们的依赖和相关依赖,这里放整个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 https://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.2.5.RELEASE</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>
    <groupId>com.christy</groupId>
    <artifactId>springboot_mybatis_jsp</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <name>springboot_mybatis_jsp</name>
    <description>Demo project for Spring Boot</description>
    <properties>
        <java.version>1.8</java.version>
    </properties>
    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
        <!-- mybatis相关 -->
        <dependency>
            <groupId>org.mybatis.spring.boot</groupId>
            <artifactId>mybatis-spring-boot-starter</artifactId>
            <version>2.1.2</version>
        </dependency>
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>druid</artifactId>
            <version>1.1.12</version>
        </dependency>
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>5.1.38</version>
        </dependency>
        <!-- jsp相关 -->
        <dependency>
            <groupId>org.apache.tomcat.embed</groupId>
            <artifactId>tomcat-embed-jasper</artifactId>
        </dependency>
        <dependency>
            <groupId>jstl</groupId>
            <artifactId>jstl</artifactId>
            <version>1.2</version>
        </dependency>
    </dependencies>
    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
                <configuration>
                    <jvmArguments>-Dfile.encoding=UTF-8</jvmArguments>
                </configuration>
            </plugin>
        </plugins>
    </build>
</project>

配置application.properties

server.port=8899
# 开启jso的自动编译
server.servlet.jsp.init-parameters.development=true
# 配置视图解析器
spring.mvc.view.prefix=/
spring.mvc.view.suffix=.jsp
# 编写mybatis相关配置
spring.datasource.type=com.alibaba.druid.pool.DruidDataSource
spring.datasource.driver-class-name=com.mysql.jdbc.Driver
spring.datasource.url=jdbc:mysql://localhost:3306/christy?characterEncoding=UTF-8
spring.datasource.username=root
spring.datasource.password=123456
# 创建这个目录一定要使用 "/"
mybatis.mapper-locations=classpath:com/christy/mapper/*.xml
# 指定别名
mybatis.type-aliases-package=com.christy.model.entity
# 开启日志 日志级别: off > error > warn > info > debug > all
logging.level.root=info
logging.level.com.christy.model.dao=debug
logging.level.com.christy.controller=debug

编写代码

建表t_user

CREATE TABLE t_user (
    id INT (6) PRIMARY KEY AUTO_INCREMENT,
    NAME VARCHAR (40),
    age INT (3),
    salary DOUBLE (7, 2)
);

编写User.java

public class User {
    private Integer id;
    private String name;
    private Integer age;
    private Double salary;
    public User() {
    }
    public User(Integer id, String name, Integer age, Double salary) {
        this.id = id;
        this.name = name;
        this.age = age;
        this.salary = salary;
    }
    public Integer getId() {
        return id;
    }
    public void setId(Integer id) {
        this.id = id;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public Integer getAge() {
        return age;
    }
    public void setAge(Integer age) {
        this.age = age;
    }
    public Double getSalary() {
        return salary;
    }
    public void setSalary(Double salary) {
        this.salary = salary;
    }
    @Override
    public String toString() {
        return "User{" +
                "id=" + id +
                ", name='" + name + '\'' +
                ", age=" + age +
                ", salary=" + salary +
                '}';
    }
}
// 我们这里没有使用lombok

编写UserDao

@Mapper
public interface UserDao {
    /**
     * 查询所有
     * @author Christy
     * @date 2021/5/13 9:38
     * @param
     * @return java.util.List<com.christy.model.entity.User>
     */
    List<User> findAll();
   /**
     * 添加用户信息
     * @author Christy
     * @date 2021/5/13 9:38
     * @param user
     * @return
     */
    void save(User user);
    /**
     * 根据id查询用户
     * @author Christy
     * @date 2021/5/13 9:39
     * @param id
     * @return com.christy.model.entity.User
     */
    User findById(Integer id);
    /**
     * 修改用户信息
     * @author Christy
     * @date 2021/5/13 9:39
     * @param user
     * @return void
     */
    void update(User user);
    /**
     * 根据id删除用户
     * @author Christy
     * @date 2021/5/13 9:39
     * @param id
     * @return void
     */
    void deleteById(Integer id);
}

编写UserMapper.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.christy.model.dao.UserDao">
    <!--findAll-->
    <select id="findAll" resultType="com.christy.model.entity.User">
        select id,name,age,salary from t_user
    </select>
    <!--save 采用数据库自动生成(useGeneratedKeys="true")并返回主键的值(keyProperty保存主键的属性名)-->
    <insert id="save" parameterType="com.christy.model.entity.User" useGeneratedKeys="true" keyProperty="id" >
        insert into t_user values(#{id},#{name},#{age},#{salary})
    </insert>
    <!--findById-->
    <select id="findById" parameterType="Integer" resultType="com.christy.model.entity.User">
        select id,name,age,salary from t_user where id = #{id}
    </select>
    <!--update-->
    <update id="update" parameterType="com.christy.model.entity.User">
        update t_user
        set
            name=#{name},
            age=#{age},
            salary=#{salary}
        where id = #{id}
    </update>
    <!--deleteById-->
    <select id="deleteById" parameterType="Integer" >
        delete from t_user where id = #{id}
    </select>
</mapper>

编写UserService.java、UserServiceImpl.java

public interface UserService {
    /**
     * 查询所有用户
     * @author Christy
     * @date 2021/5/13 9:41
     * @param
     * @return java.util.List<com.christy.model.entity.User>
     */
    List<User> findAll();
    /**
     * 保存用户信息
     * @author Christy
     * @date 2021/5/13 9:42
     * @param user
     * @return void
     */
    void save(User user);
    /**
     * 根据id查询用户
     * @author Christy
     * @date 2021/5/13 9:42
     * @param id
     * @return com.christy.model.entity.User
     */
    User findById(Integer id);
    /**
     * 修改用户信息
     * @author Christy
     * @date 2021/5/13 9:42
     * @param user
     * @return void
     */
    void update(User user);
    /**
     * 根据id删除用户
     * @author Christy
     * @date 2021/5/13 9:42
     * @param id
     * @return void
     */
    void deleteById(Integer id);
}
/**
 * @Component注解 在工厂中创建对象
 * @Controller @Service @Repository都继承自@Component注解,
 * 该三个注解将三层Controller,Service,Dao区别开来,其余地方如需要创建对象需要用Component
 *
 * @Transactional
 * 修饰范围:
 *      类:代表类中所有方法加入事务
 *      方法: 代表当前方法加入事务
 * propagation: 事务的传播属性 是指发生在多个业务层之间的事务传递
 *      默认值:REQUIRED 需要事务,如果外部存在事务则融入事务,没有则开启事务
 *      REQUIRED_NEW:需要新事物 外部存在事务则事务挂起,自己创建新的事务 内部事务运行结束外部事物恢复(该传播属性常用于记录业务操作日志)
 *      SUPPORTS:支持事务,外部存在事务则融入事务,没有也不开启
 *          那么问题来了,查询方法上有必要加@Transactional(propagation = Propagation.SUPPORTS)?
 *          答:有必要。
 *          举例:A.save(){ B.find*(){ C.update() }},这是个典型的A调用B,B调用C。对于A和C都是需要事务的,事务的传播属性都是默认值REQUIRED,
 *          如果此时B没有加事务,则A的事务无法传递到C,此时C的传播属性因为是默认的REQUIRED,所以C会开启一个新的事务。这时A和C分别处于不同的事务中
 *
 * @author Christy
 * @date 2021/5/13 10:04
 **/
@Service // 通知springboot扫描该注解 用来在工厂中创建对象
@Transactional  // 控制事务 修饰范围: 类 方法
public class UserServiceImpl implements UserService {
    @Autowired
    private UserDao userDao;

    @Override
    @Transactional(propagation = Propagation.SUPPORTS)  // propagation: 事务的传播属性
    public List<User> findAll() {
        return userDao.findAll();
    }

    @Override
    public void save(User user) {
        userDao.save(user);
    }

    @Override
    public User findById(Integer id) {
        return userDao.findById(id);
    }

    @Override
    public void update(User user) {
        userDao.update(user);
    }

    @Override
    public void deleteById(Integer id) {
        userDao.deleteById(id);
    }
}

编写Controller

@Controller
@RequestMapping("user")
public class UserController {
    @Autowired
    private UserService userService;
    /**
     * 查询所有
     * @author Christy
     * @date 2021/5/13 10:48
     * @param request
     * @param model
     * @return java.lang.String
     */
    @RequestMapping("findAll")
    public String findAll(HttpServletRequest request, Model model){
        List<User> users = userService.findAll();
        //保存到作用域
        model.addAttribute("users",users);
        return "user_list";
    }
    /**
     * 添加用户
     * @author Christy
     * @date 2021/5/13 10:49
     * @param name
     * @param user
     * @return java.lang.String
     */
    @RequestMapping("save")
    public String save(String name,User user){
        userService.save(user);
        return "redirect:/user/findAll";
    }
    /**
     * 查询用户
     * @author Christy
     * @date 2021/5/13 10:49
     * @param id
     * @param model
     * @return java.lang.String
     */
    @RequestMapping("findById")
    public String findById(Integer id,Model model){
        User user = userService.findById(id);
        model.addAttribute("user",user);
        return "user_detail";
    }
    /**
     * 修改用户信息
     * @author Christy
     * @date 2021/5/13 10:50
     * @param user
     * @return java.lang.String
     */
    @RequestMapping("update")
    public String update(User user){
        userService.update(user);
        return "redirect:/user/findAll";
    }
    /**
     * 删除一个用户
     * @author Christy
     * @date 2021/5/13 10:50
     * @param id
     * @return java.lang.String
     */
    @RequestMapping("deleteById")
    public String deleteById(Integer id){
        userService.deleteById(id);
        return "redirect:/user/findAll";
    }
}

测试

我们启动项目,访问列表页面http://localhost:8899/user/findAll,然后按下图操作我们预编写的功能

以上就是Springboot集成mybatis与jsp过程详解的详细内容,更多关于Springboot集成的资料请关注我们其它相关文章!

(0)

相关推荐

  • SpringBoot集成Mybatis的实现步骤

    通过 SpringBoot +MyBatis 实现对数据库学生表的查询操作 一.实现步骤 新建一个09-springboot-web-mybatis项目,方式和之前一样,基于springboot的 1. 准备数据库 新建一个数据库springboot,指定字符编码集utf-8,并创建数据表 表名为:t_student,并插入几条数据 2. 在pom.xml 中添加相关 jar 依赖 <!--Mybatis整合springboot的起步依赖--> <dependency> <g

  • SpringBoot+MybatisPlus+Mysql+JSP实战

    本文主要介绍了SpringBoot+MybatisPlus+Mysql+JSP实战,分享给大家,具体如下: 放个效果图: 准备项目 首先在MySql控制台输入一下sql语句创建student 数据库和student. create databse student; use student; CREATE TABLE `student` ( `stu_id` bigint(20) NOT NULL, `stu_name` varchar(45) DEFAULT NULL, `stu_sex` va

  • springboot+springmvc+mybatis项目整合

    介绍: 上篇给大家介绍了ssm多模块项目的搭建,在搭建过程中spring整合springmvc和mybatis时会有很多的东西需要我们进行配置,这样不仅浪费了时间,也比较容易出错,由于这样问题的产生,Pivotal团队提供了一款全新的框架,该框架使用了特定的方式来进行配置,从而使开发人员不再需要定义样板化的配置.通过这种方式,Spring Boot致力于在蓬勃发展的快速应用开发领域(rapid application development)成为领导者. 特点: 1. 创建独立的Spring应用

  • Spring boot集成Mybatis的方法教程

    本章目标 整合 Mybatis ,并集成 Druid 数据源 可视化监控 Druid 数据源 使用 JPA 生成数据表 利用注解实现数据库的事物 利用注解动态配置数据源 全局异常捕获 校验请求参数,并将错误信息以JSON 格式返回 完成了对 Dao Service Mapper 的封装 集成 log4j2 为何 Mybatis 为何选择 Mybatis,最主要的原因大概有以下几点 它的动态绑定用起来特别爽 基本上是在写原生的 SQL 语句,看着也是很舒服,如果 SQL 写得好的话,后期维护什么的

  • springboot与mybatis整合实例详解(完美融合)

    简介 从 Spring Boot 项目名称中的 Boot 可以看出来,Spring Boot 的作用在于创建和启动新的基于 Spring 框架的项目.它的目的是帮助开发人员很容易的创建出独立运行和产品级别的基于 Spring 框架的应用.Spring Boot 会选择最适合的 Spring 子项目和第三方开源库进行整合.大部分 Spring Boot 应用只需要非常少的配置就可以快速运行起来. Spring Boot 包含的特性如下: 创建可以独立运行的 Spring 应用. 直接嵌入 Tomc

  • Springboot集成mybatis与jsp过程详解

    目录 什么是Spring Boot? springboot特点 springboot快速搭建项目 新建项目springboot_mybatis_jsp 项目配置 配置项目目录 配置工作目录(working directory) 配置pom.xml 配置application.properties 编写代码 建表t_user 编写User.java 编写UserMapper.xml 编写UserService.java.UserServiceImpl.java 编写Controller 什么是Sp

  • Springboot集成spring data elasticsearch过程详解

    版本对照 各版本的文档说明:https://docs.spring.io/spring-data/elasticsearch/docs/ 1.在application.yml中添加配置 spring: data: elasticsearch: repositories: enabled: true #多实例集群扩展时需要配置以下两个参数 #cluster-name: datab-search #cluster-nodes: 127.0.0.1:9300,127.0.0.1:9301 2.添加 M

  • SpringBoot 使用Mybatis分页插件实现详解

    这篇文章主要介绍了SpringBoot 使用Mybatis分页插件实现详解,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下 1.导入分页插件包和jpa包 <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-data-jpa</artifactId> </depende

  • SPRINGBOOT读取PROPERTIES配置文件数据过程详解

    这篇文章主要介绍了SPRINGBOOT读取PROPERTIES配置文件数据过程详解,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下 一.使用@ConfigurationProperties来读取 1.Coffer entity @Configuration @ConfigurationProperties(prefix = "coffer") @PropertySource("classpath:config/coffer.p

  • SpringBoot服务端数据校验过程详解

    这篇文章主要介绍了SpringBoot服务端数据校验过程详解,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下 对于任何一个应用而言,客户端做的数据有效性验证都不是安全有效的,而数据验证又是一个企业级项目架构上最为基础的功能模块,这时候就要求我们在服务端接收到数据的时候也对数据的有效性进行验证.为什么这么说呢?往往我们在编写程序的时候都会感觉后台的验证无关紧要,毕竟客户端已经做过验证了,后端没必要在浪费资源对数据进行验证了,但恰恰是这种思维最为容易

  • SpringBoot配置拦截器实现过程详解

    目录 如何配置拦截器 拦截器设置容易出现的问题 如何取消拦截操作 实例-登录验证 如何配置拦截器 step1: 自定义拦截器 /** * 自定义拦截器 */ public class MyInterceptor implements HandlerInterceptor { private static final Logger logger = LoggerFactory.getLogger(MyInterceptor.class); /** * 在请求匹配controller之前执行,返回t

  • IDEA搭建SpringBoot多模块聚合工程过程详解(多模块聚合工程)

    目录 一.搭建环境 (1)IDEA创建maven工程 (2)修改pom依赖 (4)创建app-pojo子工程 (5)创建app-mapper子工程 (6)创建app-service子工程 (7)创建app-web子工程 (8)统一依赖管理 (9)添加web依赖 (10)关联子工程依赖 (11)测试子工程依赖是否成功 二.集成MyBatis (1)父工程中添加MyBatis依赖管理 (2)app-mapper子工程引入MyBatis (4)配置mybatis和mysql数据源 (5)service

  • SpringBoot整合Netty心跳机制过程详解

    前言 Netty 是一个高性能的 NIO 网络框架,本文基于 SpringBoot 以常见的心跳机制来认识 Netty. 最终能达到的效果: 客户端每隔 N 秒检测是否需要发送心跳. 服务端也每隔 N 秒检测是否需要发送心跳. 服务端可以主动 push 消息到客户端. 基于 SpringBoot 监控,可以查看实时连接以及各种应用信息. IdleStateHandler Netty 可以使用 IdleStateHandler 来实现连接管理,当连接空闲时间太长(没有发送.接收消息)时则会触发一个

  • Springboot访问templates html页面过程详解

    springboot项目默认是不允许直接访问templates下的文件的,是受保护的. 如果要访问templates下的文件,推荐使用thymeleaf. 注:使用thymeleaf这一点要牢牢记住! 如何使用: 1.pom依赖 <!--thymeleaf 模板依赖--> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter

  • springboot 获取工具类bean过程详解

    这次的实践经验的起因在于,在开发中,我想在工具类中使用配置文件的变量值.通常使用@value注解,这个只能在spring中管理的bean总获取.之前我也很疑惑,为什么之前的开发人员会在SpringUtil类上加入@Component注解,今天又遇到这种情况,其原因完全理解了. @Component public class SpringUtil implements EnvironmentAware { private static Environment env; public static

随机推荐