精华内容
下载资源
问答
  • Mybatis实现增删改查

    2017-08-28 15:28:12
    使用Mybatis实现增删改查
  • 1.简介 Spring Boot是一个简化Spring开发的框架。用来监护spring应用开发,约定大于配置,去繁就简,just run 就能创建一个独立的,产品级的应用。 我们在使用Spring Boot时只需要配置相应的Spring Boot就可以用所有...
  • myeclipse下用SSM框架实现增删改查,数据库为mysql,有操作文档,便于理解,方便初学者直接运行代码去学习
  • mybatis实现增删改查

    2019-03-19 19:01:48
    mybatis实现增删改查
  • mybatis实现增删改查Java项目,适合用于熟悉mybatis原理及流程学习。
  • MyBatis是支持普通SQL查询,存储过程和高级映射的优秀持 久层框架,通过本文给大家介绍Mybatis实现增删改查及分页查询的方法,感兴趣的朋友一起学习吧
  • MyBatis实现增删改查

    2021-02-05 23:43:11
    MyBatis实现增删改查 学习内容: MyBatis CRUD 学习时间: 学习产出: MyBatis实现增删改查 注意:增删改要提交事务 XML实现增删改除 <?xml version="1.0" encoding="UTF8" ?> <!DOCTYPE mapper ...

    学习目标:

    MyBatis实现增删改查


    学习内容:

    MyBatis CRUD


    学习时间:


    学习产出:

    MyBatis实现增删改查

    注意:增删改要提交事务

    XML实现增删改除

    <?xml version="1.0" encoding="UTF8" ?>
    <!DOCTYPE mapper
            PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
            "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
    <!--namespace绑定一个对应的Dao(Mapper)接口-->
    <mapper namespace="com.mybatis.mapper.UserMapper">
        <!--select查询语句-->
        <select id="getUserList" resultType="com.mybatis.pojo.User">
            select * from user;
        </select>
        <select id="getUserById" parameterType="int" resultType="com.mybatis.pojo.User">
            select * from user where id = #{id}
        </select>
        <!--增加语句,对象中的属性可以直接取出来-->
        <insert id="addUser" parameterType="com.mybatis.pojo.User">
            insert into user (id,name,pwd) values (#{id},#{name},#{pwd})
        </insert>
        <!--修改语句-->
        <update id="updateUser" parameterType="com.mybatis.pojo.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>
    

    Mapper接口

    package com.mybatis.mapper;
    
    import com.mybatis.pojo.User;
    
    import java.util.List;
    
    public interface UserMapper {
        //查询所有用户
        List<User> getUserList();
        //根据id查询用户
        User getUserById(int id);
        //添加用户
        int addUser(User user);
        //修改用户
        int updateUser(User user);
        //删除用户
        int deleteUser(int id);
    }
    

    Test测试

    package com.mybatis.mapper;
    
    import com.mybatis.pojo.User;
    import com.mybatis.util.MyBatisUtil;
    import org.apache.ibatis.session.SqlSession;
    import org.junit.Test;
    
    import java.net.UnknownServiceException;
    import java.util.List;
    
    /**
     * @ClassName UserMapperTest
     * @Author $童一
     * @Description $
     * @Param $
     * @return $
     * @Date $ $
     **/
    
    public class UserMapperTest {
        @Test
        public void MyTest() {
            //1、获取SqlSession对象
            SqlSession sqlSession = MyBatisUtil.getSqlSession();
            //2、执行Sql
            //方式一:getMapper
            UserMapper mapper = sqlSession.getMapper(UserMapper.class);
            List<User> userList = mapper.getUserList();
            //方式二:不推荐使用
    //        List<User> userList = sqlSession.selectList("com.mybatis.mapper.UserMapper.getUserList");
            for (User user : userList) {
                System.out.println(user);
            }
            sqlSession.close();
        }
    
    
        //通过id查询用户
        @Test
        public void getUserById() {
            SqlSession sqlSession = MyBatisUtil.getSqlSession();
            UserMapper mapper = sqlSession.getMapper(UserMapper.class);
            User user = mapper.getUserById(1);
            System.out.println(user);
            sqlSession.close();
        }
    
    
        //增加用户
        @Test
        public void addUser() {
            SqlSession sqlSession = MyBatisUtil.getSqlSession();
            UserMapper mapper = sqlSession.getMapper(UserMapper.class);
            int result = mapper.addUser(new User(4, "赵六", "123123"));
            if (result > 0) {
                System.out.println("添加成功!");
            }
            //增删改一定要提交事务!
            sqlSession.commit();
            sqlSession.close();
        }
    
        //修改用户
        @Test
        public void updateUser() {
            SqlSession sqlSession = MyBatisUtil.getSqlSession();
            UserMapper mapper = sqlSession.getMapper(UserMapper.class);
            int result = mapper.updateUser(new User(5, "牛七", "987789"));
            if (result > 0) {
                System.out.println("修改成功!");
            }
            sqlSession.commit();
            sqlSession.close();
        }
    
        //删除用户
        @Test
        public void deleteUser(){
            SqlSession sqlSession = MyBatisUtil.getSqlSession();
            UserMapper mapper = sqlSession.getMapper(UserMapper.class);
            int result = mapper.deleteUser(4);
            if(result > 0){
                System.out.println("删除成功!");
            }
            sqlSession.commit();
            sqlSession.close();
        }
    }
    
    展开全文
  • SSM Spring boot,Mybatis的整合总是很麻烦,在此提供一个已经整合好三大框架的包,可以...4.实现了sakila中的单表的增删改查和跨表查询,跨表查询包括了Mybatis的1-N和N-1双向映射; 5.添加定时任务:不再使用作业自
  • SpringBoot+mybatis+Maven+mysql脚本增删改查完整源码,
  • 你还不会算我输~ springboot整合mybatis、注解和xml实现增删改查

    平凡也就两个字: 懒和惰;
    成功也就两个字: 苦和勤;
    优秀也就两个字: 你和我。
    跟着我从0学习JAVA、spring全家桶和linux运维等知识,带你从懵懂少年走向人生巅峰,迎娶白富美!
    关注微信公众号【 IT特靠谱 】,每天都会分享技术心得~

     

    springboot整合Mybatis实现增删改查

     1 前言      

          持久层框架有很多,常见的持久层框架实现有spring-data-jpa、mybatis(mybatis-plus)和hibernate等。本教程将以mybatis持久层框架为例,详述springboot整合mybatis框架的过程,并最终通过注解和xml两种方式实现数据增删改查(CRUD)操作。

     

    2 什么是mybatis?

          mybatis官方文档中的解释:MyBatis 是一款优秀的持久层框架,它支持自定义 SQL、存储过程以及高级映射。MyBatis 免除了几乎所有的 JDBC 代码以及设置参数和获取结果集的工作。MyBatis 可以通过简单的 XML 或注解来配置和映射原始类型、接口和 Java POJO(Plain Old Java Objects,普通老式 Java 对象)为数据库中的记录。

          也就是mybatis对数据库操作做了大量封装,使得开发者拿来即用,减少开发成本。同时mybatis支持注解和xml两种映射方式,也提供对原生sql的支持。

     

    3 创建springboot项目

          创建springboot项目的过程非常简单,此处省略。下面是已经建好的springboot项目的目录结构。

          项目名称:mybatis-demo

     

    4 安装mysql数据库

    4.1 安装mysql数据库      

          略!关注微信公众号:IT特靠谱,回复"我要mysql安装教程"免费领取吧~

     

    4.2 创建表并初始化数据

          mysql数据库连接信息如下:

    url: jdbc:mysql://localhost:3306/test_mybatis?useUnicode=true&characterEncoding=utf8&useSSL=false&serverTimezone=UTC
    username: root
    password: root

           创建的数据库表:user_t 给数据库表user_t添加唯一索引。索引字段为:mobile,索引名:udx_user_mobile。创建表的sql脚本如下:

    CREATE TABLE `user_t`  (
      `id` bigint(20) NOT NULL AUTO_INCREMENT COMMENT '主键id',
      `mobile` varchar(11) CHARACTER SET utf8 COLLATE utf8_general_ci NOT NULL COMMENT '用户手机号',
      `user_name` varchar(20) CHARACTER SET utf8 COLLATE utf8_general_ci NOT NULL COMMENT '用户名',
      `age` tinyint(4) NULL DEFAULT NULL COMMENT '年龄',
      `create_time` timestamp(0) NOT NULL DEFAULT CURRENT_TIMESTAMP COMMENT '创建时间',
      `update_time` timestamp(0) NOT NULL DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP(0) COMMENT '最后更新时间',
      PRIMARY KEY (`id`) USING BTREE,
      UNIQUE INDEX `udx_user_mobile`(`mobile`) USING BTREE COMMENT '用户手机号唯一索引'
    ) ENGINE = InnoDB AUTO_INCREMENT = 10 CHARACTER SET = utf8 COLLATE = utf8_general_ci ROW_FORMAT = Dynamic;

     

         

          我们先往user_t数据库表中插入如下4条数据,用于查询测试!

    INSERT INTO `user_t` VALUES (1, '13111111111', '张三', 10, '2020-10-22 15:58:51', '2020-10-22 18:26:31');
    INSERT INTO `user_t` VALUES (2, '13555555555', '李四', 20, '2020-10-22 15:58:59', '2020-10-22 18:26:33');
    INSERT INTO `user_t` VALUES (3, '13666666666', '王五', 20, '2020-10-22 15:59:15', '2020-10-22 18:26:35');
    INSERT INTO `user_t` VALUES (4, '15222222222', '小六', 40, '2020-10-22 17:30:21', '2020-10-22 18:26:39');

     

     

    5 springboot整合mybatis

    5.1 引入jar包

          项目pom.xml文件中添加mysql数据库驱动、数据库连接池和mybatis相关依赖包。

        <!--持久化api依赖包:与数据库交互,比如Java bean和数据库表的对应关系-->
        <dependency>
          <groupId>javax.persistence</groupId>
          <artifactId>persistence-api</artifactId>
          <version>1.0</version>
        </dependency>
    
        <!--mybatis依赖包-->
        <dependency>
          <groupId>org.mybatis.spring.boot</groupId>
          <artifactId>mybatis-spring-boot-starter</artifactId>
          <version>2.1.1</version>
        </dependency>
    
        <!-- mybatis通用Mapper依赖包:提供了基本的增删改查Mapper -->
        <dependency>
          <groupId>tk.mybatis</groupId>
          <artifactId>mapper-spring-boot-starter</artifactId>
          <version>1.2.4</version>
        </dependency>
    
        <!--mysql数据库驱动包-->
        <dependency>
          <groupId>mysql</groupId>
          <artifactId>mysql-connector-java</artifactId>
          <version>5.1.35</version>
        </dependency>
    
        <!--Druid数据库连接池-->
        <dependency>
          <groupId>com.alibaba</groupId>
          <artifactId>druid-spring-boot-starter</artifactId>
          <version>1.1.10</version>
        </dependency>

     

    5.2 配置数据源

          在application.properties或application.yml配置文件中添加如下配置。

          1)配置数据源

          2)指定Mapper.xml资源文件所在路径

          3)开启sql日志

    #mysql配置数据源
    spring:
      datasource:
        driver-class-name: com.mysql.jdbc.Driver
        url: jdbc:mysql://localhost:3306/test_mybatis?useUnicode=true&characterEncoding=utf8&useSSL=false&serverTimezone=UTC
        username: root
        password: root
    
    #指定Mapper.xml所在路径
    mybatis:
      mapper-locations: classpath:mapping/*Mapper.xml
      type-aliases-package: com.hc.mybatisdemo.entity
    
    #打印sql日志
    logging:
      level:
        com:
          hc:
            mybatisdemo:
              mapper: debug

     

    5.3 扫描Mapper接口

    //注意这里需要引入tk.mybatis这个依赖
    import tk.mybatis.spring.annotation.MapperScan;
    import org.springframework.boot.SpringApplication;
    import org.springframework.boot.autoconfigure.SpringBootApplication;
    
    @SpringBootApplication
    @MapperScan("com.hc.mybatisdemo.mapper") //扫描的mapper包路径
    public class MybatisDemoApplication {
    
      public static void main(String[] args) {
        SpringApplication.run(MybatisDemoApplication.class, args);
      }
    }

     

    6 编写代码实现增删CRUD

    6.1 创建实体类

           实体类: User.java

    import com.fasterxml.jackson.annotation.JsonFormat;
    import java.util.Date;
    import javax.persistence.Column;
    import javax.persistence.GeneratedValue;
    import javax.persistence.GenerationType;
    import javax.persistence.Id;
    import javax.persistence.Table;
    import lombok.AllArgsConstructor;
    import lombok.Builder;
    import lombok.Data;
    import lombok.NoArgsConstructor;
    import org.springframework.format.annotation.DateTimeFormat;
    
    /**
     * 用户实体类
     */
    @Data
    @Builder
    @NoArgsConstructor
    @AllArgsConstructor
    @Table(name = "user_t")
    public class User {
    
      /**
       * 主键id
       */
      @Id
      @GeneratedValue(strategy = GenerationType.IDENTITY)
      @Column(name = "id")
      private Long id;
    
      /**
       * 用户手机号
       */
      @Column(name = "mobile")
      private String mobile;
    
      /**
       * 用户名
       */
      @Column(name = "user_name")
      private String userName;
    
      /**
       * 年龄
       */
      @Column(name = "age")
      private Integer age;
    
      /**
       * 创建时间
       */
      @DateTimeFormat(pattern="yyyy-MM-dd HH:mm:ss") //写入数据库时格式化
      @JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss",timezone = "GMT+8") //数据库查询后json格式化
      @Column(name = "create_time")
      private Date createTime;
    
      /**
       * 创建时间
       */
      @DateTimeFormat(pattern="yyyy-MM-dd HH:mm:ss")
      @JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss",timezone = "GMT+8")
      @Column(name = "update_time")
      private Date updateTime;
    }

     

    6.2 创建Mapper接口类

          Mapper接口类:UserMapper.java

    import com.hc.mybatisdemo.entity.User;
    import java.util.List;
    import org.apache.ibatis.annotations.Delete;
    import org.apache.ibatis.annotations.Insert;
    import org.apache.ibatis.annotations.Mapper;
    import org.apache.ibatis.annotations.Param;
    import org.apache.ibatis.annotations.Select;
    import org.apache.ibatis.annotations.Update;
    import tk.mybatis.mapper.common.BaseMapper;
    import tk.mybatis.mapper.common.MySqlMapper;
    
    /**
     * UserMapper接口
     */
    @Mapper
    public interface UserMapper extends BaseMapper<User>, MySqlMapper<User> {
    
      /**
       * 根据id查询
       */
      User findById(Long id);
    
      /**
       * 根据用户名获取用户信息 注意:like模糊查询的占位符用${},不能用#{}
       */
      @Select(value = "select id, mobile, user_name as userName, age, create_time as createTime, update_time as updateTime from user_t where user_name like '%${userName}'")
      List<User> findByUserName(@Param("userName") String userName);
    
      /**
       * 更新id数据的用户名和年龄信息方式1
       */
      @Update(value = "update user_t set user_name = #{userName}, age = #{age} where id = #{id}")
      Integer updateById1(@Param("userName") String userName, @Param("age") Integer age, @Param("id") Long id);
    
      /**
       * 删除id数据方式1
       */
      @Delete(value = "delete from user_t where id = #{id}")
      Integer deleteById1(@Param("id") Long id);
    
      /**
       * 更新数据方式2
       */
      Integer updateById2(User user);
    
      /**
       * 删除id数据方式2
       *
       * @param id 被删除的数据id
       */
      Integer deleteById2(Long id);
    }

     

    6.3 创建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.hc.mybatisdemo.mapper.UserMapper">
    
      <resultMap id="BaseResultMap" type="com.hc.mybatisdemo.entity.User">
        <result column="id" jdbcType="VARCHAR" property="id"/>
        <result column="mobile" jdbcType="VARCHAR" property="mobile"/>
        <result column="user_name" jdbcType="VARCHAR" property="userName"/>
        <result column="age" jdbcType="INTEGER" property="age"/>
        <result column="create_time" jdbcType="TIMESTAMP" property="createTime"/>
        <result column="update_time" jdbcType="TIMESTAMP" property="updateTime"/>
      </resultMap>
    
      <select id="findById" resultMap="BaseResultMap">
        select * from user_t where id = #{id}
      </select>
    
      <!--<select id="findById" resultType="com.hc.mybatisdemo.entity.User">-->
      <!--select * from user_t where id = #{id}-->
      <!--</select>-->
    
      <update id="updateById" parameterType="com.hc.mybatisdemo.entity.User">
        update user_t set user_name = #{userName}, age = #{age} where id = #{id};
      </update>
    
      <delete id="deleteById" parameterType="String">
        delete from user_t where id = #{id};
      </delete>
    </mapper>

     

    6.4 创建业务层接口类

          创建业务层接口类:IUserService.java

    import com.hc.mybatisdemo.entity.User;
    import java.util.List;
    import org.springframework.stereotype.Service;
    
    /**
     * 用户service接口
     */
    @Service
    public interface IUserService {
    
      /**
       * 查询一个
       */
      User findOne(Long id);
    
      /**
       * 根据用户名获取用户列表
       */
      List<User> findByUserName(String userName);
    
      /**
       * 插入一条数据
       */
      Integer insert(User user);
    
      /**
       * 更新一条数据
       */
      Integer updateById(User user);
    
      /**
       * 删除一条数据
       */
      Integer deleteById(Long id);
    
      /**
       * 事务控制测试--删除id1和id2两条数据
       */
      Integer transactionTest(Long id1, Long id2);
    }

     

    6.5 创建业务层接口实现类

          创建业务层接口实现类:UserServiceImpl.java

    import com.hc.mybatisdemo.entity.User;
    import com.hc.mybatisdemo.mapper.UserMapper;
    import com.hc.mybatisdemo.service.IUserService;
    import java.util.List;
    import lombok.extern.slf4j.Slf4j;
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.stereotype.Service;
    import org.springframework.transaction.annotation.Transactional;
    import org.springframework.transaction.interceptor.TransactionAspectSupport;
    
    /**
     * 用户service实现类
     */
    @Slf4j
    @Service
    public class UserServiceImpl implements IUserService {
    
      @Autowired
      private UserMapper userMapper;
    
      /**
       * 查询一个
       */
      @Override
      public User findOne(Long id) {
        return userMapper.findById(id);
      }
    
      /**
       * 根据用户名获取用户列表
       */
      @Override
      public List<User> findByUserName(String userName) {
        return userMapper.findByUserName(userName);
      }
    
      /**
       * 新增一条数据
       */
      @Override
      public Integer insert(User user) {
        return userMapper.insertSelective(user);
      }
    
      /**
       * 更新一条数据
       */
      @Override
      public Integer updateById(User user) {
    //        return userDao.updateById1(user.getUserName(), user.getAge(), user.getId());
        return userMapper.updateById2(user);
      }
    
      /**
       * 删除一条数据
       */
      @Override
      public Integer deleteById(Long id) {
    //        return userDao.deleteById1(id);
        return userMapper.deleteById2(id);
      }
    
      /**
       * 事务控制测试--删除id1和id2两条数据
       */
      @Override
      @Transactional(rollbackFor = Exception.class)
      public Integer transactionTest(Long id1, Long id2) {
        try {
          userMapper.deleteById1(id1);
          userMapper.deleteById1(id2);
          int a = 0;
          int b = 10 / a;//模拟抛出异常
        } catch (Exception e) {
          TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
          return 0;
        }
        return 1;
      }
    }

     

    6.6 创建控制层api类

          创建控制层api类:UserController.java

    import com.hc.mybatisdemo.entity.User;
    import com.hc.mybatisdemo.service.IUserService;
    import java.util.List;
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.web.bind.annotation.DeleteMapping;
    import org.springframework.web.bind.annotation.GetMapping;
    import org.springframework.web.bind.annotation.PostMapping;
    import org.springframework.web.bind.annotation.PutMapping;
    import org.springframework.web.bind.annotation.RequestBody;
    import org.springframework.web.bind.annotation.RequestMapping;
    import org.springframework.web.bind.annotation.RestController;
    
    /**
     * 用户控制器
     */
    @RestController
    @RequestMapping(value = "/user")
    public class UserController {
    
      @Autowired
      private IUserService userService;
    
      /**
       * 根据id查询
       */
      @GetMapping(value = "findOne")
      public User findOne(Long id) {
        User user = userService.findOne(id);
        return user;
      }
    
      /**
       * 根据用户名获取用户列表
       */
      @GetMapping(value = "findByUserName")
      public List<User> findByUserName(String userName) {
        return userService.findByUserName(userName);
      }
    
      /**
       * 新增一条数据
       */
      @PostMapping(value = "insert")
      public Integer insert(@RequestBody User user) {
        return userService.insert(user);
      }
    
      /**
       * 更新一条数据
       */
      @PutMapping(value = "update")
      public Integer update(@RequestBody User user) {
        return userService.updateById(user);
      }
    
      /**
       * 根据用户名获取用户列表
       */
      @DeleteMapping(value = "delete")
      public Integer delete(Long id) {
        return userService.deleteById(id);
      }
    
      /**
       * 事务控制测试
       */
      @GetMapping(value = "transactionTest")
      public Integer transactionTest(Long id1, Long id2) {
        return userService.transactionTest(id1, id2);
      }
    }

     

    7 测试API

    7.1 根据id查询一条数据

          查询id为2的数据。

     

    7.2 模糊查询

          左模糊查询。查询以“五”结尾的用户名数据。

     

    7.3 保存一条数据

          插入一条用户名为“老七”的记录。

          保存结果:

     

    7.4 更新一条数据

          将id为5的数据的用户名更新为“老七七”,年龄更新为75。

          更新后结果:

     

    7.5 删除一条数据

          删除id为5的数据。

          删除后结果:

     

    7.6 事务控制(Transaction)测试

          调用事务控制测试api接口(接口的业务层会删除id为1和2的两条数据),但是我们人为埋下了一个抛出异常的代码(int b = 10/a;)。理想结果:由于代码抛出异常,那么两条数据都不会被删除,因为事务回滚了!

          调用接口,删除id为1和2的两条数据:

          测试结果如下,可见事务回滚了。id为1和2的数据都没有删除成功。证明了同一个事务种mysql操作的原子性和一致性。

          关注微信公众号并回复"我要mybatis整合源码",免费获取本教程mybatis-demo源码~

    展开全文
  • springboot+mybatis+postman+crud(视频+源码) https://pan.baidu.com/s/1qYcFDow https://blog.csdn.net/linzhiqiang0316/article/details/78310884?locationNum=3&fps=1
  • 简单的mybatis框架搭建,实现了 曾删改 功能连接mysql数据库。后期将上传ssm整合框架
  • SpringBoot整合MybatisMybatis简介准备工作创建SpringBoot项目添加相关依赖全局配置文件创建数据表增删改查创建实体类创建mapper接口service业务层Controller控制层测试 Mybatis简介 MyBatis 是一款优秀的持久层框架...

    一. Mybatis简介

    MyBatis 是一款优秀的持久层框架,它支持自定义 SQL、存储过程以及高级映射。MyBatis 免除了几乎所有的 JDBC 代码以及设置参数和获取结果集的工作。MyBatis 可以通过简单的 XML 或注解来配置和映射原始类型、接口和 Java POJO(Plain Old Java Objects,普通老式 Java 对象)为数据库中的记录。

    二. 准备工作

    创建SpringBoot项目

    这篇文章中有SpringBoot项目的创建:启动SpringBoot《从零开始的Springboot》

    添加相关依赖

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

    全局配置文件

    spring.datasource.url=jdbc:mysql://localhost:3306/demo?&useSSL=false&serverTimezone=UTC
    spring.datasource.username=root
    spring.datasource.password=root
    spring.datasource.driver-class-name=com.mysql.cj.jdbc.Driver
    

    创建数据表

    create table user(
    id int primary key not null,
    userName varchar(32),
    userAge varchar(32)
    

    三. 增删改查

    创建实体类

    public class User {
        private Long id;
        private String userName;
        private Integer userAge;
        //...get/set()
    }
    

    创建mapper接口

    @Mapper
    @Component
    public interface UserMapper {
        //查询所有记录
        @Select("select * from user")
        List<User> getUsers();
        //根据id删除记录
        @Delete("delete from user where id =#{id}")
        int delete(int id);
        //更新一条记录
        @Update("insert into user(id,userName,userAge)values(#id,#userName,#userAge)")
        User update(User user);
        //增加一条数据
        @Insert("insert into user(id,userName,userAge)values(#{id},#{userName},#{userAge})")
        User save(User user);
    }
    

    由于我在使用@Autowire注解将mapper类自动注入的时候发现can not autowired错误,于是我在类前面加上了@Component将该类标注为一个组件。

    service业务层

    由于功能简单,就直接在service中直接写,不再写service和对应的实现类了。

    @Service
    public class UserService {
        @Autowired
        private UserMapper userMapper;
        /*
        查询所有数据
         */
        public List<User> getUsers() {
            return userMapper.getUsers();
        }
        /*
        修改数据
         */
        public User update(User user) {
            return userMapper.update(user);
        }
        /*
        添加一条数据
         */
        public User save(User user) {
            return userMapper.save(user);
        }
        /*
        根据id删除数据
         */
        public int delete(int id) {
            return userMapper.delete(id);
        }
    }
    

    Controller控制层

    @RestController
    public class UserController {
    
        @Autowired
        private UserService userService;
        @GetMapping("/users")
        public List<User> lists() {
            return userService.getUsers();
        }
        @GetMapping("/delete")
        public int  delete(int id){
            return userService.delete(id);
        }
        @RequestMapping("/update")
        public void update(User user) {
            userService.update(user);
        }
        @RequestMapping("/save")
        public void save(User user) {
            userService.save(user);
        }
    }
    

    四.测试

    打开浏览器在地址栏输入:localhost:8080/users 如下图:
    在这里插入图片描述
    使用配置的druid可以实现监控功能。
    在这里插入图片描述

    部分内容引用:mybatis简介:https://mybatis.org/mybatis-3/zh/index.html

    展开全文
  • MyBatis 是支持普通 SQL 查询,存储过程和高级映射的优秀持久层框架。通过本文给大家介绍Mybatis实现增删改查(CRUD)实例代码 ,需要的朋友参考下
  • 微信小程序+springboot+mybatis实现增删改查(微信小程序端).rar
  • Mybatis 一、介绍 Mybatis是支持普通SQL查询,存储过程和高级映射的优秀持久层框架。Mybatis消除了几乎所有的jdbc代码和参数的手工设置以及对结果集的检索封装。Mybatis可以使用简单的xml或注解用于配置和原始映射。...

    Mybatis

    一、介绍

    Mybatis是支持普通SQL查询,存储过程和高级映射的优秀持久层框架。Mybatis消除了几乎所有的jdbc代码和参数的手工设置以及对结果集的检索封装。Mybatis可以使用简单的xml或注解用于配置和原始映射。将接口的pojo(plain old java objects,实体类,普通的java对象)映射成数据库中的记录。

    持久层:把Java对象保存到数据库的过程就是持久层 dao层mybatis半自动化框架,必须写SQL语句

    JDBC->dbutils->MyBatis->Hibernate

    二、mybatis快速入门

    编写一个基于Mybatis的测试例子(增删改查):

    • 步骤:
      • 1.导入 mybatis.jar包

        【mybatis】
        mybatis-3.1.1.jar
        【MYSQL 驱动包】
        mysql-connector-java-5.1.7-bin.jar
        
      • 2.添加mybatis的配置文件mybatis-conf.xml

        <?xml version="1.0" encoding="UTF-8"?>
        <!DOCTYPE configuration PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-config.dtd">
        <configuration>
        <environments default="development">
        <environment id="development">
        <transactionManager type="JDBC" />
        <dataSource type="POOLED">
        <property name="driver" value="com.mysql.jdbc.Driver" />
        <property name="url" value="jdbc:mysql://localhost:3306/mybatis" />
        <property name="username" value="root" />
        <property name="password" value="root" />
        </dataSource>
        </environment>
        </environments>
        </configuration>
        
      • 3.定义表所对应的实体类

        public class User {
            private int id;
            private String name;
            private int age;
        }
        
      • 4.定义操作user表的sql映射文件UserMapper.xml

        <mapper namespace="dong">
            <!--
                resultType:实体类的全局路径
            -->
            <select id="getUser" parameterType="int" resultType="com.hong.entity.User">
                 select * from users where id=#{id}
            </select>
        
            <insert id="insertUser" >
                insert into users(name,age) values(#{name},#{age})
            </insert>
        
            <delete id="deleteUser">
                delete from users where id=#{id}
            </delete>
        
            <update id="updateUser">
                update users set name=#{name } where id=#{id}
            </update>
        
      • 5.在mybatis-conf.xml文件中注册userMapper.xml

        <mappers>
                <!--映射文件的路径-->
                <mapper resource="mapper/UserMapper"></mapper>
            </mappers>
        
      • 6.编写测试代码:执行定义的select语句

        //1. 读取配置文件
                Reader reader = Resources.getResourceAsReader("mybatis-config");
                //2. 构建Session工厂
                SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(reader);
                //3. 创建能执行映射文件中的sql的sqlSession
                SqlSession sqlSession = sqlSessionFactory.openSession();
                //4.执行sql
                //查询
                /*User user = sqlSession.selectOne("dong.getUser", 1);
                System.out.println(user);*/
                //新增
                /*int insert = sqlSession.insert("dong.insertUser", new User(4, "丁丁", 18));
                //事务提交
                sqlSession.commit();
                System.out.println("a!!!!!!!!!!");*/
                //删除
                /*int delete = sqlSession.delete("dong.deleteUser", 4);
                sqlSession.commit();
                System.out.println("a~~~~~~~~~~`");*/
                //修改
                int jhon = sqlSession.update("dong.updateUser", new User(2, "Jhon", 11));
                sqlSession.commit();
                System.out.println("a~~~~~~~~~~~~~~``");
        

    三、操作user表的crud

    3.1 XML的实现

    1. 定义SQL映射xml文件:
    <insert id="insertUser" parameterType="com.hong.entity.User">
    insert into user(name, age) values(#{name}, #{age});
    </insert>
    <delete id="deleteUser" parameterType="int">
    delete from user where id=#{id}
    </delete>
    <update id="updateUser" parameterType="com.hong.entity.User">
    update user set name=#{name},age=#{age} where id=#{id}
    </update>
    <select id="getOneUser" parameterType="int" resultType="com.hong.entity.User">
    select * from user where id=#{id}
    </select>
    <select id="getAllUser" resultType="com.hong.entity.User">
    select * from user
    </select>
    
    1. 在mybatis-config.xml中注册这个映射文件
    <mappers>
    	<mapper resource="com/hong/mybatis_test/test1/UserMapper.xml"/>
    </mappers>
    

    四、实际开发的模式

    接口结合映射文件一起用

    1.创建一个接口

    public interface UserDao {
        /**
         * 查询所有的用户信息
         */
        public List<User> getAllUser();
    
        /**
         * 根据id查询用户信息
         */
        //@Param:表示把该参数的名称作为映射文件的参数名
        public Users getByNameAndAge(int id);
    }
    

    接口中写出要写的方法

    2. 创建映射文件

    <?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">
    <!--映射文件中 namespace必须和接口的全路径匹配-->
    <mapper namespace="com.hong.dao.UserDao">
    
        <!--
    		id 名称必须和接口中的方法名一致
    		查询语句中的resultType必须写
    	-->
        <select id="getAllUser"  resultType="com.hong.entity.User">
             select * from users
        </select>
        
        <select id="getByNameAndAge" resultType="com.hong.entity.User">
             select * from users where id=#{id}
        </select>
    </mapper>
    
    展开全文
  • Spring+Mybatis实现增删改查 源码下载:spring_mybatis 一、 创建maven工程 项目结构如下 二、 添加相关依赖 打开pom.xml文件,添加spring和mybatis的相关依赖 三、 创建spring配置文件 新建名为...
  • Springboot整合mybatis实现增删改查 1、创建springboot项目,我使用的是IDEA,直接File->New->Project->
  • IDEA SpringBoot整合Mybatis实现增删改查操作

    万次阅读 多人点赞 2019-09-06 11:23:44
    验证 到这里就完成了增删改查操作,接下来我们对上面的代码在Postman中进行验证 8.1通过用户id获取用户信息: http://localhost:8080/testBoot/getUser/1 (此处1为要获取的id) 8.2通过用户id删除用户 ...
  • 本文通过实例代码给大家介绍了mybatis实现增删改查功能,非常不错,具有参考借鉴价值,需要的朋友参考下吧
  • 记录一下springboot+mybatis实现增删改查的基本流程和心得 springboot是一个spring家族中举足轻重的那一个,也是在javaweb实际开发过程经常使用到的一个框架,熟练使用springboot是在实际工作中非常重要的。(在一...
  • Mybatis通用增删改查

    2017-05-26 18:10:39
    Mybatis通用增删改查 有基础的DaoImpl
  • 为了给初学者一些快速上手的前后端都包含的demo,特意以最简单的方式实现这个实例。 里面包含的有后端的增删改查代码以及html页面去调用接口实现前后端交互。
  • 主要介绍了Spring boot + mybatis + Vue.js + ElementUI 实现数据的增删改查实例代码,非常不错,具有参考借鉴价值,需要的朋友可以参考下
  • SpringBoot整合MyBatis实现MySQL数据库表增删改查。需使用Maven项目,搭建本地仓库。
  • mybatis实现增删改查
  • Eclipse:SpringBoot+mybatis实现增删改查

    千次阅读 2019-05-30 17:26:13
    此项目代码已上传至github:... 1.新建数据库spring_mybatis 2.新建表user 表中字段id,name,password,id为主键并自增 3.进入网址https://start.spring.io/新建springboot项目,此处可参考博文https...
  • 常用的方式实现 1.编写sql映射文件 ...其中在实现插入数据的时候,发现我插入进数据库中的数据都是问号,经过盘查之后发现,在MyBatis框架与数据库进行交互的时候会有编码的问题,所以数据库链接这里有一个...
  • 本项目适合初学者,框架集合后做的ssm整合,支持增删改查,模糊查询,有bug敬请指正

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 35,197
精华内容 14,078
关键字:

mybatis实现增删改查