springboot+mybatis 简单的增删改查

新建项目。选择Spring Initializr。勾选spring web，lombok

目录结构

pom.xml 添加依赖。

1. mybatis-spring-boot-starter ： 相当于引入了三个jar    - mybatis-spring-boot-autoconfigure.jar    - mybatis.jar    - mybatis-spring.jar

2. mysql-connector-java ：为了连接数据库，引入的mysql 驱动包

 <!--Mybatis Framework-->
        <dependency>
        <groupId>org.mybatis.spring.boot</groupId>
            <artifactId>mybatis-spring-boot-starter</artifactId>
            <version>2.1.3</version>
        </dependency>
        <!--mysql connector-->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <scope>runtime</scope>
        </dependency>

mybatis-config.xml 写mybatis配置文件

<?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>
    <properties>
        <!-- 数据库类型：MySQL、Oracle -->
        <property name="dbtype" value="MySQL"/>
        <property name="defaultDateFormat" value="yyyy-MM-dd hh:mm:ss"/>
    </properties>
    <settings>
        <!--logImpl 可选的值有：SLF4J、LOG4J、LOG4J2、JDK_LOGGING、COMMONS_LOGGING、
       STDOUT_LOGGING、NO_LOGGING -->
        <setting name="logImpl" value="SLF4J"/>
        <!--全局地开启或关闭配置文件中的所有映射器已经配置的任何缓存。 有效值 true |
       false 默认值 true-->
        <setting name="cacheEnabled" value="true"/>
        <!--延迟加载的全局开关。当开启时，所有关联对象都会延迟加载。 特定关联关系中可通
       过设置 fetchType 属性来覆盖该项的开关状态。-->
        <!-- 有效值 true | false 默认值 false -->
        <setting name="lazyLoadingEnabled" value="true"/>
        <setting name="aggressiveLazyLoading" value="true"/>
        <!--是否允许单⼀语句返回多结果集（需要驱动⽀持）有效值 true | false 默认值
       true-->
        <setting name="multipleResultSetsEnabled" value="true"/>
        <!-- 使⽤列标签代替列名。不同的驱动在这⽅⾯会有不同的表现，具体可参考相关驱动文
       档或通过测试这两种不同的模式来观察所⽤驱动的结果。 -->
        <!-- 有效值 true | false 默认值 true -->
        <setting name="useColumnLabel" value="true"/>
        <!-- 允许 JDBC ⽀持⾃动⽣成主键，需要驱动⽀持。有效值 true | false 默认值
       false
        如果设置为 true 则这个设置强制使⽤⾃动⽣成主键，尽管⼀些驱动不能⽀持但仍可正常⼯
       作（比如 Derby） -->
        <setting name="useGeneratedKeys" value="true"/>
        <!--
        指定 MyBatis 应如何⾃动映射列到字段或属性。
        NONE 表⽰取消⾃动映射；
        PARTIAL 只会⾃动映射没有定义嵌套结果集映射的结果集。
        FULL 会⾃动映射任意复杂的结果集（⽆论是否嵌套）
        有效值：NONE, PARTIAL, FULL
        默认值: PARTIAL -->
        <setting name="autoMappingBehavior" value="PARTIAL"/>
        <!--
        指定发现⾃动映射⽬标未知列（或者未知属性类型）的⾏为。
        NONE: 不做任何反应
        WARNING: 输出提醒⽇志
       ('org.apache.ibatis.session.AutoMappingUnknownColumnBehavior' 的⽇志等级必须设置为
       WARN)
        FAILING: 映射失败 (抛出 SqlSessionException)
        有效值：NONE, WARNING, FAILING
        默认值:NONE
        -->
        <setting name="autoMappingUnknownColumnBehavior" value="WARNING"/>
        <!--配置默认的执⾏器。
         SIMPLE 就是普通的执⾏器；
         REUSE 执⾏器会重⽤预处理语句（prepared statements）；
         BATCH 执⾏器将重⽤语句并执⾏批量更新。
         有效值:SIMPLE REUSE BATCH
         默认值:SIMPLE-->
        <setting name="defaultExecutorType" value="REUSE"/>
        <!--设置超时时间，它决定驱动等待数据库响应的秒数。
         有效值:任意正整数
         默认值：未设置 (null)
         -->
        <setting name="defaultStatementTimeout" value="25"/>
        <!-- <setting name="defaultStatementTimeout" value="25000"/>-->
        <!--是否开启⾃动驼峰命名规则（camel case）映射，即从经典数据库列名 A_COLUMN 到
        经典 Java 属性名 aColumn 的类似映射。
         有效值 true | false 默认值 false -->
        <setting name="mapUnderscoreToCamelCase" value="true"/>
        <!-- MyBatis 利⽤本地缓存机制（Local Cache）防⽌循环引⽤（circular
        references）和加速重复嵌套查询。
         默认值为 SESSION，这种情况下会缓存⼀个会话中执⾏的所有查询。
         若设置值为 STATEMENT，本地会话仅⽤在语句执⾏上，对相同 SqlSession 的不同调⽤将
        不会共享数据。
 SESSION | STATEMENT
 默认值:SESSION-->
        <setting name="localCacheScope" value="SESSION"/>
        <!--当没有为参数提供特定的 JDBC 类型时，为空值指定 JDBC 类型。
         某些驱动需要指定列的 JDBC 类型，多数情况直接⽤⼀般类型即可，比如 NULL、VARCHAR
        或 OTHER。
         有效值：JdbcType 常量，常⽤值：NULL, VARCHAR 或 OTHER。
         默认值：OTHER-->
        <setting name="jdbcTypeForNull" value="OTHER"/>
        <!--指定哪个对象的⽅法触发⼀次延迟加载。
         ⽤逗号分隔的⽅法列表。
         equals,clone,hashCode,toString-->
        <setting name="lazyLoadTriggerMethods"
                 value="equals,clone,hashCode,toString"/>
    </settings>
    <typeAliases>
    </typeAliases>
</configuration>

在resources⽬录下, 新建application.yml和application-dev.yml之后，删除 application.properties⽂件
application.yml

spring:
  profiles:
    active: dev

application-dev.yml

port:端口号

url：自己的数据库地址加上?characterEncoding=utf8&useSSL=false&serverTimezone=UTC&allowPublicKeyRetrieval=true

username:

password:

server:
  port: 8081
  servlet:
    context-path: /
spring:
  application:
    name: spring-boot
  # 配置Datasource
  datasource:
    driver-class-name: com.mysql.cj.jdbc.Driver
    url: jdbc:mysql://localhost:3306/springboot_db?characterEncoding=utf8&useSSL=false&serverTimezone=UTC&allowPublicKeyRetrieval=true
    username: root
    password: root
# mybatis配置
mybatis:
  type-aliases-package: com.example.demospringboot.model
  # mybatis-config场所
  config-location: classpath:/mybatis/mybatis-config.xml
  # mapper文件场所
  mapper-locations: classpath:/mapper/*Mapper.xml
  check-config-location: true

User.java存储实体类

@Getter
@Setter
@ToString
public class User implements Serializable {
    private long userId;
    private String userName;
    private Integer userAge;
    private Integer userSex;

}

UserDao.java 写mybatis接口

@Mapper
//@Repository
public interface UserDao {
    int insertUser(User user);

    int deleteUserByUserId(Long userId);

    int updateUser(User user);

    User selectUserByUserId(Long userId);

    List<User> selectAllUser();

    List<User> selectAllUserByCondition(Map<String, Object> queryMap);
}

UserMapper.xml接口xml实现类，映射实现接口，写SQL操作语句。

namespace=“Dao地址”,绑定Dao接口

resulttype=“返回对象” 

userMap 返回集合

resultMapcolumn = “数据库列名” property=“实体类属性名”

操作语句中的id，parameterType与Dao接口一一对应

扫描二维码关注公众号，回复： 12894194 查看本文章

<!DOCTYPE mapper
        PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.example.demospringboot.dao.UserDao">
    <resultMap type="User" id="userMap">
        <id column="user_id" property="userId" />
        <result column="user_name" property="userName" />
        <result column="user_age" property="userAge" />
        <result column="user_sex" property="userSex" />
    </resultMap>
    <insert id="insertUser" parameterType="User" >
        INSERT INTO t_user(user_name, user_age)
        VALUES(#{userName}, #{userAge});
    </insert>
    <delete id="deleteUserByUserId" parameterType="java.lang.Long">
        DELETE FROM t_user
        WHERE user_id = #{userId}
    </delete>
    <update id="updateUser" parameterType="User" >
        UPDATE t_user
        <set>
            <if test="userName != null">
                user_name= #{userName},
            </if>
            <if test="userAge != null">
                user_age= #{userAge},
            </if>
        </set>
        WHERE user_id = #{userId}
    </update>
    <sql id="userFieldSQLId">
        user_id,
        user_name,
        user_age,
        user_sex
    </sql>
    <select id="selectUserByUserId"
            parameterType="java.lang.Long"
            resultMap="userMap">
        SELECT <include refid="userFieldSQLId"/>
        FROM t_user
        WHERE user_id = #{userId}
    </select>
    <select id="selectAllUser"
            resultMap="userMap">
        SELECT <include refid="userFieldSQLId"/>
        FROM t_user
    </select>
    <select id="selectAllUserByCondition"
            parameterType="java.util.Map"
            resultMap="userMap">
        SELECT
        <include refid="userFieldSQLId"/>
        FROM t_user
        <where>
            <if test="userName != null and '' != userName">
                AND user_name = #{userName}
            </if>
            <if test="userAge !=null and '' != userAge ">
                AND user_age = #{userAge}
            </if>
            <if test="userId !=null and ''!=userAge ">
                AND user_id = #{userId}
            </if>
        </where>
    </select>

 

IUser.java 写service层接口。直接调⽤持久层是⼀个错误的选择⽅式，我们如果想使⽤MyBatis框架，后期可能也想使⽤JPA。这是我们需要 为我们的应⽤创建⼀个service的接⼝层和实现类，然后在service层的实现类中指定DAO层使⽤MyBatis还是 JPA。 

具体介绍https://blog.csdn.net/wxljmy77/article/details/88415310

//不直接调用持久层dao
public interface IUser {

    int addUser(User user);

    int removedUserByUserId(Long userId);

    int modifyUser(User user);

    User findUserByUserId(Long userId);

    List<User> findAllUser();

    //根据条件查询⽤户信息
    List<User> findAllUserByCondition(Map<String, Object> queryMap);
}

UserService.java 写service实现类。implements IUser

@Service
public class UserService implements IUser {

    private final UserDao userDao;
    @Autowired
    public UserService(UserDao userDao) {
        this.userDao = userDao;
    }

    @Override
    public int addUser(User user) {
        return userDao.insertUser(user);
    }

    @Override
    public int removedUserByUserId(Long userId) {
        return userDao.deleteUserByUserId(userId);
    }

    @Override
    public int modifyUser(User user) {
        return userDao.updateUser(user);
    }

    @Override
    public User findUserByUserId(Long userId) {
        return userDao.selectUserByUserId(userId);
    }

    @Override
    public List<User> findAllUser() {
        return userDao.selectAllUser();
    }

    @Override
    public List<User> findAllUserByCondition(Map<String, Object> queryMap) {
        return userDao.selectAllUserByCondition(queryMap);
    }


}

 

UserController.java

@RestController
public class    UserController {

    private final UserService userService;
    @Autowired
    public UserController(UserService userService) {
        this.userService = userService;
    }


    //查询所有user
    @GetMapping(value = "/alluser")
    public List<User> findAllUser() {
        return userService.findAllUser();
    }

    //按Id查询user
    @GetMapping(value = "/iduser")
    public User findUserByUserId(Long userId){
        return userService.findUserByUserId(userId);
    }

    //插入user
    @PostMapping(value = "/insertuser")
    public String addUser(User user) {

        userService.addUser(user);
        return "插入信息成功";
    }

    //修改user
    @PostMapping(value = "/updateuser")
    public String modifyUser(User user) {

        userService.modifyUser(user);
        return "修改信息成功";
    }

    //多条件查询user
    @GetMapping(value = "/conditionuser")
    public List<User> findAllbycondition(@RequestParam(value = "userName")String userName, @RequestParam(value = "userAge",required = false)Integer userAge){
        //ArrayList userList;
        List<User> userList ;
        Map<String,Object> queryMap = new HashMap<>();
        queryMap.put("userName",userName);
        if (null == userAge) {
            queryMap.put("userAge", null);
        } else {
            queryMap.put("userAge", userAge);
        }
        userList =  userService.findAllUserByCondition(queryMap);
        return  userList;
    }


    //删除user
    @PostMapping(value = "deleteuser")
    public String removedUserByUserId(Long userId){

        userService.removedUserByUserId(userId);
        return "删除信息成功";
    }
}