devbox
小舞很执着
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

02-一文带你学会Mybatis基本使用（基于XML配置，收藏查阅使用）_mybatis xml 使用数据链路

作者：小舞很执着 | 2024-08-16 19:12:50

赞

踩

mybatis xml 使用数据链路

《Mybatis使用手册》（第2篇 / 共5篇，持续更新），收藏 + 关注 不迷路，希望对小伙伴们有所帮助哦~

源码链接在文末 ↓ ↓ ↓

OGNL表达式：

ognl 表达式：它是 apache 提供的一种表达式语言，在 struts2 中也有应用。
Object Graphic Navigation Language 对象图导航语言 它是按照一定的语法格式来获取数据的。
语法格式： #{对象.对象}
例如：#{user.username} 会先去找 user 对象，然后在 user 对象中找到 username 属性，并把值取出来

1、基于代理DAO实现CRUD操作

【注意】

  1. 持久层接口和持久层接口的映射配置必须在相同的包下；
  2. 持久层映射配置中 mapper 标签的 namespace 属性取值必须是持久层接口的全限定类名；
  3. SQL 语句的配置标签<select>、<insert>、<delete>、<update> 的 id 属性必须和持久层接口的 方法名相同。
  • 主配置文件
<configuration>
  <environments default="mysql">
    <environment id="mysql">
      <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>

  <mappers>
    <mapper resource="com/junlong/dao/UserDao.xml"/>
  </mappers>
</configuration>

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17

1.1、查询所有

1.1.1、持久层接口

public interface UserDao {   
    /**
     * 查询所有用户
     *
     * @return 返回用户实体列表
     */
    List<User> findAll();
}

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8

1.1.2、映射配置文件

<mapper namespace="com.junlong.dao.UserDao">
  <!-- 查询所有用户 -->
  <select id="findAll" resultType="com.junlong.domain.User">
    select * from user
  </select>
</mapper>

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6

1.1.3、测试

public class UserDaoTest {
    private SqlSession sqlSession;
    private InputStream in;
    private UserDao userDao;
    @Before
    public void init() throws IOException {
        in = Resources.getResourceAsStream("SqlMapConfig.xml");
        SqlSessionFactoryBuilder builder = new SqlSessionFactoryBuilder();
        SqlSessionFactory factory = builder.build(in);
        sqlSession = factory.openSession();
        userDao = sqlSession.getMapper(UserDao.class);
    }

    @After
    public void destroy() throws IOException {
        sqlSession.commit();
        sqlSession.close();
        in.close();
    }

    /**
     * 测试查询所有
     */
    @Test
    public void testFindAll() {
        List<User> users = userDao.findAll();
        for (User user : users) {
            System.out.println(user);
        }
    }
}

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31

1.2、根据id查询

1.2.1、持久层接口

public interface UserDao {   
    /**
     * 根据id查询用户
     *
     * @param id 用户id
     * @return 返回用户对象
     */
    User findById(int id);
}

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9

1.2.2、映射配置文件

<mapper namespace="com.junlong.dao.UserDao">
  <!-- 根据id查询用户 -->
  <select id="findById" parameterType="int" resultType="com.junlong.domain.User">
    select * from user where id = #{id}
  </select>
</mapper>

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6

1.2.3、测试

/**
     * 测试根据id查询用户
     */
@Test
public void testFindById() {
    User user = userDao.findById(41);
    System.out.println(user);
}

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8

1.3、新增操作

1.3.1、持久层接口

public interface UserDao {   
    /**
     * 新增用户
     *
     * @param user 用户对象
     */
    void addUser(User user);
}

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8

1.3.2、映射配置文件

<mapper namespace="com.junlong.dao.UserDao">
  <insert id="addUser" parameterType="com.junlong.domain.User">
    <selectKey keyColumn="id" keyProperty="id" resultType="int">
      select last_insert_id()
    </selectKey>
    insert into user (username, birthday, sex, address) values (#{username}, #{birthday}, #{sex}, #{address})
  </insert>
</mapper>

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8

1.3.3、测试

/**
     * 测试新增用户
     */
@Test
public void testAddUser() {
    User user = new User();
    user.setUsername("小师妹");
    user.setBirthday(new Date());
    user.setSex("女");
    user.setAddress("北京市工人体育馆");
    userDao.addUser(user);
    System.out.println(user);
}

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13

1.4、更新操作

1.4.1、持久层接口

public interface UserDao {   
    /**
     * 根据id更新用户信息
     *
     * @param user 用户对象
     */
    void updateUser(User user);
}

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8

1.4.2、映射配置文件

<mapper namespace="com.junlong.dao.UserDao">
  <!-- 更新用户信息 -->
  <update id="updateUser" parameterType="com.junlong.domain.User">
    update user set username = #{username}, birthday = #{birthday}, sex = #{sex}, address = #{address} where id = #{id}
  </update>
</mapper>

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6

1.4.3、测试

/**
     * 测试更新用户
     */
@Test
public void testUpdateUser() {
    User user = new User();
    user.setId(69);
    user.setUsername("大师姐");
    user.setBirthday(new Date());
    user.setSex("女");
    user.setAddress("北京市三里屯");
    userDao.updateUser(user);
}

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13

1.5、删除操作

1.5.1、持久层接口

public interface UserDao {   
    /**
     * 根据id删除用户
     *
     * @param id 用户id
     */
    void delUser(int id);
}

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8

1.5.2、映射配置文件

<mapper namespace="com.junlong.dao.UserDao">
  <!-- 根据id删除用户 -->
  <delete id="delUser" parameterType="int">
    delete from user where id = #{id}
  </delete>
</mapper>

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6

1.5.3、测试

/**
     * 测试根据id删除用户
     */
@Test
public void testDelUser() {
    userDao.delUser(73);
}

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7

1.6、模糊查询

1.6.1、持久层接口

public interface UserDao {   
    /**
     * 根据用户名模糊查询用户
     *
     * @param name 用户名
     * @return 返回用户对象列表
     */
    List<User> findByName(String name);
}

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9

1.6.2、映射配置文件

<mapper namespace="com.junlong.dao.UserDao">
  <!-- 根据用户名模糊查询 -->
  <select id="findByName" parameterType="String" resultType="com.junlong.domain.User">
    select * from user where username like #{username}
  </select>
</mapper>

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6

1.6.3、测试

/**
     * 测试根据用户名模糊查询用户
     */
@Test
public void testFindByName() {
    List<User> users = userDao.findByName("%王%");
    for (User user : users) {
        System.out.println(user);
    }
}

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10

1.7、聚合函数查询

1.7.1、持久层接口

public interface UserDao {   
    /**
     * 查询用户总记录数
     *
     * @return 返回int类型的用户总记录数
     */
    int findTotal();
}

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8

1.7.2、映射配置文件

<mapper namespace="com.junlong.dao.UserDao">
  <!-- 聚合函数查询用户总记录数 -->
  <select id="findTotal" resultType="int">
    select count(*) from user
  </select>
</mapper>

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6

1.7.3、测试

/**
* 查询用户总记录数
*/
@Test
public void testFindTotal() {
    int total = userDao.findTotal();
    System.out.println(total);
}

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8

1.8、Mybatis和JDBC编程的比较

  1. 数据库链接创建、释放频繁造成系统资源浪费从而影响系统性能，如果使用数据库链接池可解决此问题。

【解决】在 SqlMapConfig.xml 中配置数据链接池，使用连接池管理数据库链接。

  1. .Sql 语句写在代码中造成代码不易维护，实际应用 sql 变化的可能较大，sql 变动需要改变 java 代码。

【解决】将 Sql 语句配置在 XXXXmapper.xml 文件中与 java 代码分离。

  1. 向 sql 语句传参数麻烦，因为 sql 语句的 where 条件不一定，可能多也可能少，占位符需要和参数对应。

【解决】Mybatis 自动将 java 对象映射至 sql 语句，通过 statement 中的 parameterType 定义输入参数的 类型。

  1. 对结果集解析麻烦，sql 变化导致解析代码变化，且解析前需要遍历，如果能将数据库记录封装成 pojo 对 象解析比较方便。

【解决】Mybatis 自动将 sql 执行结果映射至 java 对象，通过 statement 中的 resultType 定义输出结果的 类型。

2、Mybatis的参数

2.1、parameterType配置参数

sql 语句的传参使用 parameterType 属性来设定。该属性的取值可以 是基本类型，引用类型（例如:String 类型），还可以是实体类类型（POJO 类）。同时也可以使用实体类的包装类。

【注意】

  1. 基本类型和 String 等包装类：可以直接写类型名称，也可以使用 包名.类名 的方式，例如：java.lang.String。
  2. 实体类类型：使用全限定类名。（在自定义了别名之后，可以使用别名）
  • Mybatis 官方定义的别名

别名

2.2、传递POJO包装对象

开发中通过 pojo 传递查询条件 ，查询条件是综合的查询条件，不仅包括用户查询条件还包括其它的查询条件（比如将用户购买商品信息也作为查询条件），这时可以使用包装对象传递输入参数。Pojo 类中包含 pojo。

  • 示例：根据用户名查询用户信息，查询条件放到 QueryVo 的 user 属性中。
  • 主配置文件
<configuration>
  <environments default="mysql">
    <environment id="mysql">
      <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>

  <mappers>
    <mapper resource="com/junlong/dao/UserDao.xml" />
  </mappers>
</configuration>

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 查询条件Vo类
public class QueryVo implements Serializable {
    private User user;

    public User getUser() {
        return user;
    }

    public void setUser(User user) {
        this.user = user;
    }
}

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 用户持久层接口
public interface UserDao {
    /**
     * 根据条件查询所有用户
     *
     * @param queryVo 查询条件实体类
     * @return 返回用户信息列表
     */
    List<User> findUserByVo(QueryVo queryVo);
}

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 映射配置文件
<mapper namespace="com.junlong.dao.UserDao">
  <!-- 根据条件查询所有用户 -->
  <select id="findUserByVo" parameterType="com.junlong.domain.QueryVo" resultType="com.junlong.domain.User">
    select * from user where username like #{user.username}
  </select>
</mapper>

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 测试
public class UserTest {
    private InputStream in;
    private SqlSession sqlSession;
    private UserDao userDao;

    @Before
    public void init() throws IOException {
        SqlSessionFactoryBuilder builder = new SqlSessionFactoryBuilder();
        in = Resources.getResourceAsStream("SqlMapConfig.xml");
        SqlSessionFactory sessionFactory = builder.build(in);
        sqlSession = sessionFactory.openSession();
        userDao = sqlSession.getMapper(UserDao.class);
    }

    @After
    public void destroy() throws IOException {
        sqlSession.commit();
        sqlSession.close();
        in.close();
    }

    @Test
    public void testFindByVo() {
        QueryVo queryVo = new QueryVo();
        User user = new User();
        user.setUsername("%王%");
        queryVo.setUser(user);

        List<User> users = userDao.findUserByVo(queryVo);
        for (User u : users) {
            System.out.println(u);
        }
    }
}

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34

3、Mybatis的输出结果封装

3.1、resultType配置结果类型

resultType 属性用来指定结果集的类型，支持基本类型和实体类类型。
如果注册过类型别名的，可以直接使用别名。没有注册过的必须使用全限定类名。
使用实体类名称时，实体类中的属性名称必须和查询语句中的列名保持一致，否则无法进行封装。

3.1.1、基本类型

  • 持久层接口
public interface UserDao {
    /**
     * 查询总记录数
     *
     * @return 返回总记录数
     */
    int findTotal();
}

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 映射文件
<mapper namespace="com.junlong.dao.UserDao">
  <!-- 查询总记录数 -->
  <select id="findTotal" resultType="int">
    select count(*) from user
  </select>
</mapper>

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6

3.1.2、实体类型

  • 持久层接口
public interface UserDao {
    /**
     * 查询所有用户
     *
     * @return 返回所有用户列表
     */
    List<User> findAll();
}

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 映射文件
<mapper namespace="com.junlong.dao.UserDao">
  <!-- 查询所有用户 -->
  <select id="findAll" resultType="com.junlong.domain.User">
    select * from user
  </select>

  <!-- 查询总记录数 -->
  <select id="findTotal" resultType="int">
    select count(*) from user
  </select>
</mapper>

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11

3.1.3、实体类中的属性名称和查询语句中的列名不一致的情况

  • 用户实体类
public class User implements Serializable {
    private int userId;
    private String userName;
    private Date userBirthday;
    private String userSex;
    private String userAddress;

    public int getUserId() {
        return userId;
    }

    public void setUserId(int userId) {
        this.userId = userId;
    }

    public String getUserName() {
        return userName;
    }

    public void setUserName(String userName) {
        this.userName = userName;
    }

    public Date getUserBirthday() {
        return userBirthday;
    }

    public void setUserBirthday(Date userBirthday) {
        this.userBirthday = userBirthday;
    }

    public String getUserSex() {
        return userSex;
    }

    public void setUserSex(String userSex) {
        this.userSex = userSex;
    }

    public String getUserAddress() {
        return userAddress;
    }

    public void setUserAddress(String userAddress) {
        this.userAddress = userAddress;
    }

    @Override
    public String toString() {
        return "User{" +
            "userId=" + userId +
            ", userName='" + userName + '\'' +
            ", userBirthday=" + userBirthday +
            ", userSex='" + userSex + '\'' +
            ", userAddress='" + userAddress + '\'' +
            '}';
    }
}

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46
  • 47
  • 48
  • 49
  • 50
  • 51
  • 52
  • 53
  • 54
  • 55
  • 56
  • 57
  • 58
  • 持久层接口
public interface UserDao {
    /**
     * 查询所有用户
     *
     * @return 返回所有用户列表
     */
    List<User> findAll();
}

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 映射文件（Sql语句种使用别名，和实体类保持一致）
<mapper namespace="com.junlong.dao.UserDao">
    <!-- 查询所有用户 -->
    <select id="findAll" resultType="com.junlong.domain.User">
        select id as userId, username as userName, birthday as userBirthday, sex as userSex, address as userAddress from user
    </select>
</mapper>

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6

3.2、resultMap结果类型

resultMap 标签可以建立查询的列名和实体类的属性名称不一致时建立对应关系。从而实现封装。
​

在 select 标签中使用 resultMap 属性指定引用即可。同时 resultMap 可以实现将查询结果映射为复杂类型的 pojo，比如在查询结果映射对象中包括 pojo 和 list 实现一对一查询和一对多查询。

  • 映射配置文件
<mapper namespace="com.junlong.dao.UserDao">
  <!-- 建立 User 实体类和数据库表的对应关系 -->
  <!-- type 属性：指定实体类的全限定类名 -->
  <!-- id 属性：唯一标识，给select标签引用使用 -->
  <resultMap id="userMap" type="com.junlong.domain.User">
    <!-- id标签：指定主键字段 -->
    <!-- result标签：指定非主键字段 -->
    <!-- column属性：指定数据库列名 -->
    <!-- property属性：指定实体类属性名 -->
    <id column="id" property="userId"/>
    <result column="username" property="userName"/>
    <result column="birthday" property="userBirthday"/>
    <result column="sex" property="userSex"/>
    <result column="address" property="userAddress"/>
  </resultMap>

  <!-- 查询所有用户 -->
  <select id="findAll" resultMap="userMap">
    select * from user
  </select>
</mapper>

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21

4、Mybatis传统DAO开发

使用Mybatis开发持久层，一般有两种方式：传动DAO开发（dao接口实现类）、Mapper接口代理开发
​

开发种一般使用Mapper接口代理开发的方式。

  • 持久层接口
public interface UserDao {
    /**
     * 查询所有用户
     *
     * @return 返回所有用户列表
     */
    List<User> findAll();

    /**
     * 根据id查询用户
     * @param id 用户id
     * @return 返回用户对象
     */
    User findById(int id);

    /**
     * 保存用户
     *
     * @param user 用户对象
     * @return 返回数据库影响的行数
     */
    int saveUser(User user);

    /**
     * 更新用户
     *
     * @param user 用户对象
     * @return 返回数据库影响的行数
     */
    int updateUser(User user);

    /**
     * 根据id删除用户
     * @param id 用户id
     * @return 返回数据库影响的行数
     */
    int deleteUser(int id);

    /**
     * 查询总记录数
     *
     * @return 返回总记录数
     */
    int findTotal();
}

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 持久层接口实现类
public class UserDaoImpl implements UserDao {
    private SqlSessionFactory sqlSessionFactory;

    public UserDaoImpl(SqlSessionFactory sqlSessionFactory) {
        this.sqlSessionFactory = sqlSessionFactory;
    }

    public List<User> findAll() {
        SqlSession sqlSession = sqlSessionFactory.openSession();
        List<User> users = sqlSession.selectList("com.junlong.dao.UserDao.findAll");
        sqlSession.close();
        return users;
    }

    public User findById(int id) {
        SqlSession sqlSession = sqlSessionFactory.openSession();
        User user = sqlSession.selectOne("com.junlong.dao.UserDao.findById", id);
        sqlSession.close();
        return user;
    }

    public int saveUser(User user) {
        SqlSession sqlSession = sqlSessionFactory.openSession();
        int res = sqlSession.insert("com.junlong.dao.UserDao.saveUser", user);
        sqlSession.commit();
        sqlSession.close();
        return res;
    }

    public int updateUser(User user) {
        SqlSession sqlSession = sqlSessionFactory.openSession();
        int res = sqlSession.update("com.junlong.dao.UserDao.updateUser", user);
        sqlSession.commit();
        sqlSession.close();
        return res;
    }

    public int deleteUser(int id) {
        SqlSession sqlSession = sqlSessionFactory.openSession();
        int res = sqlSession.delete("com.junlong.dao.UserDao.deleteUser", id);
        sqlSession.commit();
        sqlSession.close();
        return res;
    }

    public int findTotal() {
        SqlSession sqlSession = sqlSessionFactory.openSession();
        int res = sqlSession.selectOne("com.junlong.dao.UserDao.findTotal");
        sqlSession.close();
        return res;
    }
}

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46
  • 47
  • 48
  • 49
  • 50
  • 51
  • 52
  • 映射配置文件
<mapper namespace="com.junlong.dao.UserDao">
  <!-- 查询所有用户 -->
  <select id="findAll" resultType="com.junlong.domain.User">
    select * from user
  </select>

  <!-- 根据id查询用户 -->
  <select id="findById" resultType="com.junlong.domain.User" parameterType="int">
    select * from user where id = #{id}
  </select>

  <!-- 保存用户 -->
  <insert id="saveUser" parameterType="com.junlong.domain.User">
    <selectKey keyColumn="id" keyProperty="id" resultType="int">
      select last_insert_id();
    </selectKey>
    insert into user (username, birthday, sex, address) values (#{username}, #{birthday}, #{sex}, #{address})
  </insert>

  <!-- 更新用户 -->
  <update id="updateUser" parameterType="com.junlong.domain.User">
    update user set username = #{username}, birthday = #{birthday}, sex = #{sex}, address = #{address} where id = #{id}
  </update>

  <!-- 删除用户 -->
  <delete id="deleteUser" parameterType="int">
    delete from user where id = #{id}
  </delete>

  <!-- 查询总记录数 -->
  <select id="findTotal" resultType="int">
    select count(*) from user
  </select>
</mapper>

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 测试
public class UserTest {
    private InputStream inputStream;
    private SqlSessionFactory sqlSessionFactory;
    private UserDao userDao;

    @Before
    public void init() throws IOException {
        inputStream = Resources.getResourceAsStream("SqlMapConfig.xml");
        SqlSessionFactoryBuilder builder = new SqlSessionFactoryBuilder();
        sqlSessionFactory = builder.build(inputStream);
        userDao = new UserDaoImpl(sqlSessionFactory);
    }

    @After
    public void destroy() throws IOException {
        inputStream.close();
    }

    /**
     * 测试查询所有用户
     */
    @Test
    public void testFindAll() {
        List<User> users = userDao.findAll();
        for (User user : users) {
            System.out.println(user);
        }
    }

    /**
     * 测试根据id查询用户
     */
    @Test
    public void testFindById() {
        User user = userDao.findById(42);
        System.out.println(user);
    }

    /**
     * 测试保存用户
     */
    @Test
    public void testSaveUser() {
        User user = new User();
        user.setUsername("小姐姐");
        user.setBirthday(new Date());
        user.setSex("女");
        user.setAddress("深圳");
        int res = userDao.saveUser(user);
        System.out.println(res);
        System.out.println(user);
    }

    /**
     * 测试更新用户
     */
    @Test
    public void testUpdateUser() {
        User user = userDao.findById(74);
        user.setUsername("update user1");
        int res = userDao.updateUser(user);
        System.out.println(res);
        System.out.println(user);
    }

    /**
     * 测试根据id删除用户
     */
    @Test
    public void testDeleteUser() {
        int res = userDao.deleteUser(74);
        System.out.println(res);
    }

    /**
     * 测试查询总记录数
     */
    @Test
    public void testFindTotal() {
        int total = userDao.findTotal();
        System.out.println("共 " + total + " 条记录");
    }
}

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46
  • 47
  • 48
  • 49
  • 50
  • 51
  • 52
  • 53
  • 54
  • 55
  • 56
  • 57
  • 58
  • 59
  • 60
  • 61
  • 62
  • 63
  • 64
  • 65
  • 66
  • 67
  • 68
  • 69
  • 70
  • 71
  • 72
  • 73
  • 74
  • 75
  • 76
  • 77
  • 78
  • 79
  • 80
  • 81
  • 82
  • 83

5、SqlMapConfig.xml配置文件

5.1、配置内容

  • SqlMapConfig.xml中配置的内容和顺序

主配置文件

5.2、properties 属性

在使用 properties 标签配置时，我们可以采用两种方式指定属性配置。

5.2.1、方式一（本配置文件中指定）

<properties>
  <property name="jdbc.driver" value="com.mysql.jdbc.Driver"/>
  <property name="jdbc.url" value="jdbc:mysql://localhost:3306/mybatis"/>
  <property name="jdbc.username" value="root"/>
  <property name="jdbc.password" value="1234"/>
</properties>

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6

5.2.2、方式二（在单独的properties文件中指定）

  1. 在classpath路径下定义 db.properties 文件
jdbc.driver=com.mysql.jdbc.Driver
jdbc.url=jdbc:mysql://localhost:3306/mybatis
jdbc.username=root
jdbc.password=1234

  • 1
  • 2
  • 3
  • 4
  1. properties 标签配置

【注意】resource 属性：用于指定 properties 配置文件的位置，要求配置文件必须在类路径下
url 属性：统一资源定位符（协议、主机、端口号、URI）

<properties resource="jdbcConfig.properties" />

  • 1
  1. 在 dataSource 标签中引用上面的配置
<dataSource type="POOLED">
  <property name="driver" value="${jdbc.driver}"/>
  <property name="url" value="${jdbc.url}"/>
  <property name="username" value="${jdbc.username}"/>
  <property name="password" value="${jdbc.password}"/>
</dataSource>

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6

5.3、typeAliases 类型别名

在 SqlMapConfig.xml 中指定别名

<typeAliases>
  <!-- 单个别名定义 -->
  <typeAlias alias="user" type="com.junlong.domain.User"/>
  <!-- 批量别名定义，扫描整个包下的类，别名为类名（首字母大写或小写都可以） -->
  <package name="com.junlong.domain"/>
  <package name="其它包"/>
</typeAliases>

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7

5.4、mappers 映射器

5.4.1、 mapper resource=""

<mapper resource=""/>

  • 使用相对路径的资源
  • 如：

5.4.2、 mapper class=""

<mapper class=""/>

  • 使用mapper接口类路径
  • 如：
  • 注意：mapper 接口名称和 mapper 映射文件名称相同，且放在同一个目录中。

5.4.3、 package name=""

<package name=""/>

  • 注册指定包下的所有mapper接口
  • 如：
  • 注意：mapper 接口名称和 mapper 映射文件名称相同，且放在同一个目录中。

5.5、主配置文件示例

<configuration>
  <properties resource="jdbc.properties"/>
  <typeAliases>
    <package name="com.junlong.domain"/>
  </typeAliases>
  <environments default="mysql">
    <environment id="mysql">
      <transactionManager type="JDBC"/>
      <dataSource type="POOLED">
        <property name="driver" value="${jdbc.driver}"/>
        <property name="url" value="${jdbc.url}"/>
        <property name="username" value="${jdbc.username}"/>
        <property name="password" value="${jdbc.password}"/>
      </dataSource>
    </environment>
  </environments>

  <mappers>
    <package name="com.junlong.dao"/>
  </mappers>
</configuration>

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21

6、源码下载

源码下载链接

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/小舞很执着/article/detail/989519
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。