Mybatis详解(二)

最新推荐文章于 2024-08-31 15:05:42 发布
最新推荐文章于 2024-08-31 15:05:42 发布
阅读量338 收藏
点赞数
分类专栏： Mybatis 文章标签： mybatis
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/DjokerMax/article/details/83059769
版权

Mybatis

Mybatis映射文件

MyBatis 的真正强大在于它的映射语句，映射器的 XML 文件相对简单。如果拿它跟JDBC 代码进行对比，你会立即发现省掉了将近 95% 的代码。MyBatis 就是针对 SQL 构建的，并且比普通的方法做的更好。

SQL 映射文件有很少的几个顶级元素（按照它们应该被定义的顺序）：

cache – 给定命名空间的缓存配置。
cache-ref – 其他命名空间缓存配置的引用。
resultMap – 是最复杂也是最强大的元素，用来描述如何从数据库结果集中来加载对象。
sql – 可被其他语句引用的可重用语句块。
insert – 映射插入语句
update – 映射更新语句
delete – 映射删除语句
select – 映射查询语句 

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

select

select 元素有很多属性允许你配置，来决定每条语句的作用细节。

这里写图片描述

insert, update 和 delete

这里写图片描述

insert详解

插入语句的配置规则非常丰富，在插入语句里面有一些额外的属性和子元素用来处理主键的生成，而且有多种生成方式，我们来详细说明一下。 

1.首先，如果你的数据库支持自动生成主键的字段，那么你可以设置 useGeneratedKeys=”true”，然后再把 keyProperty 设置到目标属性上就OK。这样当我们插入之后，我们的对象会自动设置数据库返回的主键。 

<insert id="insertUser" parameterType="com.cad.domain.User" useGeneratedKeys="true" keyProperty="id">
    insert into user(username,birthday,sex,address) values(#{username},#{birthday},#{sex},#{address})
</insert>
 
 
  • 1
  • 2
  • 3
  • 4
  • 5
2.如果你的数据库还支持多行插入, 你也可以传入一个Authors数组或集合，并返回自动生成的主键。 

<insert id="insertAuthor" useGeneratedKeys="true"
    keyProperty="id">
  insert into Author (username, password, email, bio) values
  <foreach item="item" collection="AuthorList" separator=",">
    (#{item.username}, #{item.password}, #{item.email}, #{item.bio})
  </foreach>
</insert>
 
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9

sql

这个元素可以被用来定义可重用的 SQL 代码段，可以包含在其他语句中。它可以被静态地(在加载参数) 参数化. 不同的属性值通过包含的实例变化.

<sql id="userColumns"> ${alias}.id,${alias}.username,${alias}.password </sql>

<select id="selectUsers" resultType="map">
  select
    <include refid="userColumns"><property name="alias" value="t1"/></include>,
    <include refid="userColumns"><property name="alias" value="t2"/></include>
  from some_table t1
    cross join some_table t2
</select>

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

parameterType(输入类型)

我们传入的参数可以是简单数据类型，或者对象，前一天我们已经演示过，这里有一个点需要注意。

默认情况下,使用#{}格式的语法会导致 MyBatis 创建预处理语句属性并安全地设置值。这样做更安全，更迅速，通常也是首选做法，不过有时你只是想直接在 SQL 语句中插入一个不改变的字符串。比如，：ORDER BY ${columnName}。这里 MyBatis 不会修改或转义字符串。以这种方式接受从用户输出的内容并提供给语句中不变的字符串是不安全的，会导致潜在的 SQL 注入攻击，因此要么不允许用户输入这些字段，要么自行转义并检验。

resultMap

resultType可以指定将查询结果映射为pojo，但需要pojo的属性名和sql查询的列名一致方可映射成功。如果sql查询字段名和pojo的属性名不一致，可以通过resultMap将字段名和属性名作一个对应关系 ，resultMap实质上还需要将查询结果映射到pojo对象中。resultMap可以实现将查询结果映射为复杂类型的pojo，比如在查询结果映射对象中包括pojo和list实现一对一查询和一对多查询。 

例如：当我们使用resultType时

<select id="selectUsers" resultType="User">
  select id, username, hashedPassword
  from some_table
  where id = #{id}
</select> 

其实MyBatis会自动创建一个 ResultMap,基于数据库属性名来映射列到 JavaBean 的属性上，所以必须得保证数据库字段名和JavaBean属性一致。
 
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
如果列名没有精确匹配,你可以在列名上使用 select 字句的别名(一个 基本的 SQL 特性)来匹配属性。

<select id="selectUsers" resultType="User">
  select
    user_id             as "id",
    user_name           as "userName",
    hashed_password     as "hashedPassword"
  from some_table
  where id = #{id}
</select> 

 
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
但是，Mybatis给我们提供了简便强大的resultMap
例如，我们的实体类user_sex和数据库字段sex不匹配

public class User implements Serializable {
    /**
     * 
     */
    private static final long serialVersionUID = 1L;
    private Integer id;
    private String username;// 用户姓名
    private String user_sex;// 性别
    private Date birthday;// 生日
    private String address;// 地址
}  
 
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14

    <!--type为返回类型-->
    <resultMap type="com.cad.domain.User" id="userResultMap">
        <!--property为属性，column为对应的数据库字段，这样再查询就能匹配上-->
        <result property="user_sex" column="sex" />
    </resultMap>

    <select id="findUserById" parameterType="int" resultMap="userResultMap">
        select * from user where id =#{id}
    </select>

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

缓存

MyBatis 包含一个非常强大的查询缓存特性,它可以非常方便地配置和定制。MyBatis 3 中的缓存实现的很多改进都已经实现了,使得它更加强大而且易于配置。

默认情况下是没有开启缓存的,除了局部的 session 缓存,可以增强变现而且处理循环 依赖也是必须的。要开启二级缓存,你需要在你的 SQL 映射文件中添加一行

<cache/>  

 
 
  • 1

这个简单的一行有如下的功能：

  • 映射语句文件中的所有 select 语句将会被缓存。
  • 映射语句文件中的所有 insert,update 和 delete 语句会刷新缓存。
  • 缓存会使用 Least Recently Used(LRU,最近最少使用的)算法来收回。
  • 根据时间表(比如 no Flush Interval,没有刷新间隔), 缓存不会以任何时间顺序 来刷新。
  • 缓存会存储列表集合或对象(无论查询方法返回什么)的 1024 个引用。
  • 缓存会被视为是 read/write(可读/可写)的缓存,意味着对象检索不是共享的,而 且可以安全地被调用者修改,而不干扰其他调用者或线程所做的潜在修改。

缓存有一些属性：

  • eviction：收回策略，四个值：LRU ，FIFO，SOFT ，WEAK

  • lushInterval(刷新间隔)：可以被设置为任意的正整数,而且它们代表一个合理的毫秒 形式的时间段。默认情况是不设置,也就是没有刷新间隔,缓存仅仅调用语句时刷新。

  • size(引用数目)：可以被设置为任意正整数,要记住你缓存的对象数目和你运行环境的 可用内存资源数目。默认值是 1024。

  • readOnly(只读)：属性可以被设置为 true 或 false。只读的缓存会给所有调用者返回缓 存对象的相同实例。因此这些对象不能被修改。这提供了很重要的性能优势。可读写的缓存 会返回缓存对象的拷贝(通过序列化) 。这会慢一些,但是安全,因此默认是 false。

Mybatis还可以自定义缓存，可以自行去参考文档。

动态sql

MyBatis 的强大特性之一便是它的动态 SQL。我们使用JDBC时会手动拼接条件，Mybatis解决了这一情况。

if标签

动态 SQL 通常要做的事情是有条件地包含 where 子句的一部分。

    <!--根据id和姓名查找用户-->
    <select id="findUserByIdAndUsername" parameterType="com.cad.domain.User" resultType="com.cad.domain.User">
        select * from user 
        where 1=1
        <if test="id !=null and id!=''">
            and id=#{id}
        </if>
        <if test="username !=null and username !=''">
            and username =#{username}
        </if>
    </select>
 
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
public class MybatisTest {

    @Test
    public void test() throws IOException {
        String resource="config/sqlMapConfig.xml";

        InputStream in=Resources.getResourceAsStream(resource);
        SqlSessionFactoryBuilder builder= new SqlSessionFactoryBuilder();
        SqlSessionFactory factory=builder.build(in);
        SqlSession sqlSession=factory.openSession();  
        UserMapper userMapper=sqlSession.getMapper(UserMapper.class);  
        User user=new User();
        user.setId(10);
        user.setUsername("张三");
        List<User> list=userMapper.findUserByIdAndUsername(user);
        for(User u:list) {
            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

choose, when, otherwise标签

有些时候，我们不想用到所有的条件语句，而只想从中选择。针对这种情况，MyBatis 提供了 choose 元素，它有点像 Java 中的 switch 语句。

例如：提供了“id”就按“id”查找，提供了“username”就按“username”查找，若两者都没有提供，就按照otherwise里面的条件查找*。其实是蛮鸡肋的一功能。 

    <!-- 根据id和名字查找用户 -->
    <select id="findUserByIdAndUsername" parameterType="com.cad.domain.User" resultType="com.cad.domain.User">
        select * from user 
        where 1=1
        <choose>
            <when test="id != null">
              AND id = #{id}
            </when>
            <when test="username != null and username !=''">
              AND username = #{username}
            </when>
            <otherwise>
              AND sex = 1
            </otherwise>        
        </choose>
    </select>
 
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16

where标签

上面的例子我们都需要写where 1=1，因为如果不写，条件拼接就会出现很多错误，Mybatis通过where标签帮我们解决了这个问题。 

    <select id="findUserByIdAndUsername" parameterType="com.cad.domain.User" resultType="com.cad.domain.User">
        select * from user 
        <where>
            <if test="id != null">
              AND id = #{id}
            </if>
            <if test="username != null and username !=''">
              AND username = #{username}
            </if>   
        </where>
    </select>
 
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11

foreach标签

动态 SQL 的另外一个常用的必要操作是需要对一个集合进行遍历，通常是在构建 IN 条件语句的时候。 

//创建一个对象，封装一个ids
public class QueryVo {
    private List<Integer> ids;

    public List<Integer> getIds() {
        return ids;
    }

    public void setIds(List<Integer> ids) {
        this.ids = ids;
    }


}
 
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
    <!-- 根据多个id查找用户信息 -->
    <select id="findUserByIds" parameterType="com.cad.domain.QueryVo"  resultType="com.cad.domain.User"> 
        select * from user 
        where id in
        <!--如果集合是对象封装起来的，可以直接使用属性名字。-->
        <foreach collection="ids" item="item" open="(" separator="," close=")">
            #{item}
        </foreach>
    </select>
 
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
public class MybatisTest {

    @Test
    public void test() throws IOException {
        String resource="config/sqlMapConfig.xml";

        InputStream in=Resources.getResourceAsStream(resource);
        SqlSessionFactoryBuilder builder= new SqlSessionFactoryBuilder();
        SqlSessionFactory factory=builder.build(in);
        SqlSession sqlSession=factory.openSession();  
        UserMapper userMapper=sqlSession.getMapper(UserMapper.class);   
        List<Integer> l=new ArrayList<Integer>();
        l.add(10);
        l.add(16);
        l.add(22);
        QueryVo queryVo=new QueryVo();
        queryVo.setIds(l);
        List<User> list=userMapper.findUserByIds(queryVo);
        for(User u:list) {
            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

如果我们的list在某个对象内部，那么foreach时，collection可以直接使用list名字。如果我们直接new了一个数组或者list集合，collection属性必须使用array或者list，这样才能遍历到。

关联查询

前面我们讲了将简单的数据映射到对象中，可惜实际工作中的任务不总是这么简单，往往多个对象之间存在着各种关联关系，我们来看看使用Mybatis怎么处理。我们还是需要使用到resultMap

一对一映射

1.我们创建Order表与User表关联 

CREATE TABLE `orders` (
  `id` int(11) NOT NULL AUTO_INCREMENT,
  `user_id` int(11) NOT NULL COMMENT '下单用户id',
  `number` varchar(32) NOT NULL COMMENT '订单号',
  `createtime` datetime NOT NULL COMMENT '创建订单时间',
  `note` varchar(100) DEFAULT NULL COMMENT '备注',
  PRIMARY KEY (`id`),
  KEY `FK_orders_1` (`user_id`),
  CONSTRAINT `FK_orders_id` FOREIGN KEY (`user_id`) REFERENCES `user` (`id`) ON DELETE NO ACTION ON UPDATE NO ACTION
) ;


INSERT INTO `orders` VALUES ('3', '1', '1000010', '2015-02-04 13:22:35', null);
INSERT INTO `orders` VALUES ('4', '1', '1000011', '2015-02-03 13:22:41', null);
INSERT INTO `orders` VALUES ('5', '10', '1000012', '2015-02-12 16:13:23', null);

 
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
2.创建对应的实体类  

public class Orders  implements Serializable{

    private static final long serialVersionUID = 1L;

    private Integer id;

    private Integer userId;

    private String number;

    private Date createtime;

    private String note;

    private User user;


    public User getUser() {
        return user;
    }

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

    public Integer getId() {
        return id;
    }

    public void setId(Integer id) {
        this.id = id;
    }

    public Integer getUserId() {
        return userId;
    }

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

    public String getNumber() {
        return number;
    }

    public void setNumber(String number) {
        this.number = number == null ? null : number.trim();
    }

    public Date getCreatetime() {
        return createtime;
    }

    public void setCreatetime(Date createtime) {
        this.createtime = createtime;
    }

    public String getNote() {
        return note;
    }

    public void setNote(String note) {
        this.note = note == null ? null : note.trim();
    }

}
 
 
  • 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
3.编写映射文件 

<mapper namespace="com.cad.domain.OrdersMapper"> 
    <resultMap type="com.cad.domain.Orders" id="orders"> 
        <!--只会映射指定的字段，其他未显式指定的都为null-->
        <id property="id" column="id"/>
        <result property="userId" column="user_id"/>
        <result property="number" column="number"/>
        <!--用association表示关联的对象，property为属性名，javaType为类型-->
        <association property="user" javaType="com.cad.domain.User">
            <id column="user_id" property="id"/>
            <result property="username" column="username"/>
        </association>
    </resultMap>

    <select id="findOrders" resultMap="orders">
        SELECT * FROM orders LEFT JOIN USER ON orders.user_id=user.id
    </select>
</mapper>
 
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
4.编写Mapper接口，将映射文件添加到核心配置文件中，然后测试 

public class MybatisTest {

    @Test
    public void test() throws IOException {
        String resource="config/sqlMapConfig.xml";

        InputStream in=Resources.getResourceAsStream(resource);
        SqlSessionFactoryBuilder builder= new SqlSessionFactoryBuilder();
        SqlSessionFactory factory=builder.build(in);
        SqlSession sqlSession=factory.openSession();  
        OrdersMapper mapper=sqlSession.getMapper(OrdersMapper.class); 
        List<Orders> list=mapper.findOrders();
        for(Orders o:list) {
            System.out.println("order:"+o.toString());
            System.out.println("user:"+o.getUser().toString());
        }
    } 

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

一对多关联

1.我们在user实体类中添加orders字段

public class User implements Serializable {
    /**
     * 
     */
    private static final long serialVersionUID = 1L;
    private Integer id;
    private String username;// 用户姓名
    private String sex;// 性别
    private Date birthday;// 生日
    private String address;// 地址
    private List<Orders> orders;



    public List<Orders> getOrders() {
        return orders;
    }
    public void setOrders(List<Orders> orders) {
        this.orders = orders;
    }
    public Integer getId() {
        return id;
    }
    public void setId(Integer id) {
        this.id = id;
    }
    public String getUsername() {
        return username;
    }
    public void setUsername(String username) {
        this.username = username;
    }


    public String getSex() {
        return sex;
    }
    public void setSex(String sex) {
        this.sex = sex;
    }
    public Date getBirthday() {
        return birthday;
    }
    public void setBirthday(Date birthday) {
        this.birthday = birthday;
    }
    public String getAddress() {
        return address;
    }
    public void setAddress(String address) {
        this.address = address;
    }
    @Override
    public String toString() {
        return "User [id=" + id + ", username=" + username + ", sex=" + sex
                + ", birthday=" + birthday + ", address=" + address + ",orders"+orders+"]";
    }


}
 
 
  • 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
2.配置映射文件 

    <resultMap type="com.cad.domain.User" id="users">
        <id property="id" column="id"/>
        <result property="username" column="username"/>
        <!--这里使用ofType指定集合内部存储对象的类型-->
        <collection property="orders" ofType="com.cad.domain.Orders">
            <id column="oid" property="id"/>
            <result property="number" column="number"/>
        </collection>
    </resultMap>
    <select id="findUserOrders" resultMap="users">
        SELECT u.*,o.id oid,o.number FROM  user u LEFT JOIN orders o ON o.user_id=u.id
    </select>
 
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
3.将方法添加到mapper接口中，我们测试一下 
public class MybatisTest {

    @Test
    public void test() throws IOException {
        String resource="config/sqlMapConfig.xml";

        InputStream in=Resources.getResourceAsStream(resource);
        SqlSessionFactoryBuilder builder= new SqlSessionFactoryBuilder();
        SqlSessionFactory factory=builder.build(in);
        SqlSession sqlSession=factory.openSession();  
        OrdersMapper mapper=sqlSession.getMapper(OrdersMapper.class); 
        List<User> list=mapper.findUserOrders();
        for(User u:list) {
            System.out.println("user:"+u.toString());

        }
    } 

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

Mybatis整合Spring

1.创建空项目，导入jar包 ，mybtias-spring.jar很重要，可以去maven下载

 
 
  • 1
  • 2

这里写图片描述 

2.创建SqlMapConfig.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>
    <mappers>
        <!--映射该包下的所有映射文件-->
        <package name="com.cad.mapper"/>
    </mappers>
</configuration>
 
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
3.创建Mapper接口和Mapper映射文件  

public interface UserMapper {
    public List<User> findUsers();
}

 
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
<?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.cad.mapper.UserMapper">
    <select id="findUsers" resultType="com.cad.domain.User">
        select * from user
    </select>
</mapper>   
 
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
4.创建Spring配置文件applicationContext.xml

<?xml version="1.0" encoding="UTF-8"?> 
<beans xmlns="http://www.springframework.org/schema/beans"
    xmlns:context="http://www.springframework.org/schema/context" xmlns:p="http://www.springframework.org/schema/p"
    xmlns:aop="http://www.springframework.org/schema/aop" xmlns:tx="http://www.springframework.org/schema/tx"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-4.0.xsd
    http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-4.0.xsd
    http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-4.0.xsd http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-4.0.xsd
    http://www.springframework.org/schema/util http://www.springframework.org/schema/util/spring-util-4.0.xsd">

<!-- 配置数据库连接池 -->
<bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
    <property name="driverClass" value="com.mysql.jdbc.Driver"></property>
    <property name="jdbcUrl" value="jdbc:mysql://localhost:3306/mybatis"></property>
    <property name="user" value="root"></property>
    <property name="password" value="123456"></property>
</bean> 
<!-- 配置sqlSession工厂 -->
<bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
    <!-- 配置核心配置文件 -->
    <property name="configLocation" value="classpath:SqlMapConfig.xml"></property>
    <!-- 配置数据源 -->
    <property name="dataSource" ref="dataSource"></property>
</bean>  

<!-- 配置接口，帮我们生成代理实现类 -->
<bean id="userMapper" class="org.mybatis.spring.mapper.MapperFactoryBean">
    <!--传入工厂和接口-->
    <property name="sqlSessionFactory" ref="sqlSessionFactory"></property>
    <property name="mapperInterface" value="com.cad.mapper.UserMapper"></property>
</bean>

</beans>
 
 
  • 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
5.测试一下 

public class TestDemo {

    @Test
    public void test() {
        ApplicationContext applicationContext=new ClassPathXmlApplicationContext("classpath:applicationContext.xml");
        //获取接口实现类
        UserMapper mapper=(UserMapper)applicationContext.getBean("userMapper");
        List<User> list=mapper.findUsers();
        for(User user:list) {
            System.out.println(user.toString());
        }
    }
}
 
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15

上面的整合看似简便了不少，但是有一个严重的问题。我们每多一个Mapper接口，就得需要在Spring配置文件中多加一个配置，这是一个很繁琐并且工作量很大的工作，Mybatis为我们提供了一个扫描包的功能，可以直接将该包下的接口创建实现类。 

<?xml version="1.0" encoding="UTF-8"?> 
<beans xmlns="http://www.springframework.org/schema/beans"
    xmlns:context="http://www.springframework.org/schema/context" xmlns:p="http://www.springframework.org/schema/p"
    xmlns:aop="http://www.springframework.org/schema/aop" xmlns:tx="http://www.springframework.org/schema/tx"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-4.0.xsd
    http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-4.0.xsd
    http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-4.0.xsd http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-4.0.xsd
    http://www.springframework.org/schema/util http://www.springframework.org/schema/util/spring-util-4.0.xsd">

<!-- 配置数据库连接池 -->
<bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
    <property name="driverClass" value="com.mysql.jdbc.Driver"></property>
    <property name="jdbcUrl" value="jdbc:mysql://localhost:3306/mybatis"></property>
    <property name="user" value="root"></property>
    <property name="password" value="123456"></property>
</bean> 
<!-- 配置sqlSession工厂 -->
<bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
    <!-- 配置核心配置文件 -->
    <property name="configLocation" value="classpath:SqlMapConfig.xml"></property>
    <!-- 配置数据源 -->
    <property name="dataSource" ref="dataSource"></property>
</bean> 

<!--配置扫描方式，创建代理类，不用配置id，每个代理类的id就是接口名，首字母小写-->
<bean class="org.mybatis.spring.mapper.MapperScannerConfigurer">
    <!--配置包-->
    <property name="basePackage" value="com.cad.mapper"/>
</bean>

</beans>
 
 
  • 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

Mybatis逆向工程

我们实际开发中，动辄上百张表，如果一一地去编写对应的pojo和mapper文件，简直是噩梦。Mybatis为我们提供了一个逆向工程，可以根据单表自动生成mybatis执行所需要的（mapper.Java,mapper.xml、po..）等，免去我们不少麻烦，我们来学习一下怎么使用。 

官方逆向工程开发文档 
http://www.mybatis.org/generator/configreference/xmlconfig.html
 
 
  • 1
  • 2
1.创建新工程，导入jar包，需要mybatis.jar、mysql驱动和mybatis-generator-core.jar


 
 
  • 1
  • 2
  • 3
2.创建配置文件 genreatorConfig.xml 

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE generatorConfiguration
  PUBLIC "-//mybatis.org//DTD MyBatis Generator Configuration 1.0//EN"
  "http://mybatis.org/dtd/mybatis-generator-config_1_0.dtd">

<generatorConfiguration>
    <context id="testTables" targetRuntime="MyBatis3">
        <commentGenerator>
            <!-- 是否去除自动生成的注释 true：是 ： false:否 -->
            <property name="suppressAllComments" value="true" />
        </commentGenerator>
        <!--数据库连接的信息：驱动类、连接地址、用户名、密码 -->
        <jdbcConnection driverClass="com.mysql.jdbc.Driver"
            connectionURL="jdbc:mysql://localhost:3306/mybatis" userId="root"
            password="123456">
        </jdbcConnection>
        <!-- <jdbcConnection driverClass="oracle.jdbc.OracleDriver"
            connectionURL="jdbc:oracle:thin:@127.0.0.1:1521:yycg" 
            userId="yycg"
            password="yycg">
        </jdbcConnection> -->

        <!-- 默认false，把JDBC DECIMAL 和 NUMERIC 类型解析为 Integer，为 true时把JDBC DECIMAL 和 
            NUMERIC 类型解析为java.math.BigDecimal -->
        <javaTypeResolver>
            <property name="forceBigDecimals" value="false" />
        </javaTypeResolver>

        <!-- targetProject:生成PO类的位置 -->
        <javaModelGenerator targetPackage="cn.cad.domain"
            targetProject=".\src">
            <!-- enableSubPackages:是否让schema作为包的后缀 -->
            <property name="enableSubPackages" value="false" />
            <!-- 从数据库返回的值被清理前后的空格 -->
            <property name="trimStrings" value="true" />
        </javaModelGenerator>
        <!-- targetProject:mapper映射文件生成的位置 -->
        <sqlMapGenerator targetPackage="cn.cad.mapper" 
            targetProject=".\src">
            <!-- enableSubPackages:是否让schema作为包的后缀 -->
            <property name="enableSubPackages" value="false" />
        </sqlMapGenerator>
        <!-- targetPackage：mapper接口生成的位置 -->
        <javaClientGenerator type="XMLMAPPER"
            targetPackage="cn.cad.mapper" 
            targetProject=".\src">
            <!-- enableSubPackages:是否让schema作为包的后缀 -->
            <property name="enableSubPackages" value="false" />
        </javaClientGenerator>
        <!-- 指定数据库表 -->
        <table schema="" tableName="user"></table>
        <table schema="" tableName="orders"></table>

        <!-- 有些表的字段需要指定java类型
         <table schema="" tableName="">
            <columnOverride column="" javaType="" />
        </table> -->
    </context>
</generatorConfiguration>
 
 
  • 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
3.使用java程序加载配置文件生成我们需要的代码  ，这段java程序在官方文档里面有，直接复制过来即可 

public class GeneratorSqlmap {

    public void generator() throws Exception{

        List<String> warnings = new ArrayList<String>();
        boolean overwrite = true;
        //指定 逆向工程配置文件
        File configFile = new File("generatorConfig.xml"); 
        ConfigurationParser cp = new ConfigurationParser(warnings);
        Configuration config = cp.parseConfiguration(configFile);
        DefaultShellCallback callback = new DefaultShellCallback(overwrite);
        MyBatisGenerator myBatisGenerator = new MyBatisGenerator(config,
                callback, warnings);
        myBatisGenerator.generate(null);

    } 
    public static void main(String[] args) throws Exception {
        try {
            GeneratorSqlmap generatorSqlmap = new GeneratorSqlmap();
            generatorSqlmap.generator();
        } catch (Exception e) {
            e.printStackTrace();
        }

    }

}

 
 
  • 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

这里写图片描述 

4.生成的Mapper接口中有很多常用的方法，并且我们发现除了生成POJO类，还生成了Example类，这个类是用来加条件的，如查询条件等。
  我们来演示一下。
 
 
  • 1
  • 2
public class TestDemo {

    @Test
    public void test() {
        ApplicationContext applicationContext=new ClassPathXmlApplicationContext("classpath:applicationContext.xml");
        UserMapper mapper=(UserMapper)applicationContext.getBean("userMapper");
        UserExample example=new UserExample(); 
        //添加性别为1的条件
        example.createCriteria().andSexEqualTo("1");
        int count=(int) mapper.countByExample(example);
        System.out.println(count);
    }
}
 
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
					<link href="https://csdnimg.cn/release/phoenix/mdeditor/markdown_views-778f64ae39.css" rel="stylesheet">
            </div>
zhumqs
关注
专栏目录
MyBatis入门到精通——入门篇
猿小白的博客
04-16 3430
目录一、什么是 MyBatis？二、入门案例（1）创建maven项目（2）引入依赖包（3）创建数据库执行sql脚本三、入门程序源码（1）User.java（2）UserMapper.java（3）MybatisUtils.java（4）UserMapperTest.java（6）UserMapper.xml（7）mybatis-config.xml（8）pom.xml 四、程序单元测试结果五、程序完整源码获取在此之前，需要提前配置好java环境变量和maven环境变量。 （3）创建数据库执行sql
Mybatis从入门到精通 (二)
春水上行的博客
08-14 1592
MybatisMybatis映射文件MyBatis 的真正强大在于它的映射语句，映射器的 XML 文件相对简单。如果拿它跟JDBC 代码进行对比，你会立即发现省掉了将近 95% 的代码。MyBatis 就是针对 SQL 构建的，并且比普通的方法做的更好。 SQL 映射文件有很少的几个顶级元素（按照它们应该被定义的顺序）：cache – 给定命名空间的缓存配置。 cache-ref – 其他命名空间
数据库字段映射：MyBatis 自动映射 vs. 手动映射（反射与 Switch）
最新发布
weixin_54574094的博客
08-31 1170
在 Java 应用程序中，数据库字段与 Java 对象属性之间的映射是常见的需求。本文将对比两种常见的映射方法：MyBatis 的自动映射与手动映射（包括反射和。因此，在实际开发中，建议使用 MyBatis 的自动映射机制以提高开发效率和代码可维护性。希望这篇文章能帮助你更好地理解不同数据库字段映射方式的优缺点，并在你的项目中做出最合适的选择。对于大多数应用场景，MyBatis 提供了最简洁、自动化的解决方案，特别是当涉及到常见的数据库映射需求时。语句将数据库字段映射到 Java 对象属性。
Mybatis从入门到精通 (一)
zfcsdn2017的博客
12-15 565
MybatisMybatis简介MyBatis 本是apache的一个开源项目iBatis, 2010年这个项目由apache software foundation 迁移到了google code，并且改名为MyBatis 。2013年11月迁移到Github。 MyBatis 是支持普通SQL、存储过程以及高级映射的优秀的持久层框架。MyBatis 避免了几乎所有的 JDBC 代码和手动设置参数
MyBatis从入门到精通(1)：MyBatis入门
weixin_30555125的博客
07-11 508
作为一个自学Java的自动化专业211大学本科生，在学习和实践过程中”趟了不少雷“，所以有志于建立一个适合同样有热情学习Java技术的参考“排雷手册”。 最近在读刘增辉老师所著的《MyBatis从入门到精通》一书，很有收获，于是将自己学习的过程以博客形式输出，如有错误，欢迎指正！ 第1章 MyBatis入门 1.1 MyBatis简介 MyBatis是一款支持自定义SQL查询、存储过程和高级映...
《MyBatis 从入门到精通》源代码
04-04
电子工业出版社的《MyBatis 从入门到精通》的源代码。本书中从一个简单的 MyBatis 查询入手，搭建起学习 MyBatis 的基础开发环境。通过全面的示例代码和测试讲解了在 MyBatis XML 方式和注解方式中进行增、删、改、查操作的基本用法，介绍了动态 SQL 在不同方面的应用以及在使用过程中的最佳实践方案。针对 MyBatis 高级映射、存储过程和类型处理器提供了丰富的示例，通过自下而上的方法使读者更好地理解和掌握MyBatis 的高级用法，同时针对 MyBatis 的代码生成器提供了详细的配置介绍。此外，本书还提供了缓存配置、插件开发、Spring、Spring Boot 集成的详细内容。最后通过介绍 Git 和 GitHub 让读者了解MyBatis 开源项目，通过对 MyBatis 源码和测试用例的讲解让读者更好掌握 MyBatis。
mybatis详解(全)
热门推荐
Ferao的博客
03-21 15万+
mybatis详解
mybatis详解源码
01-21
MyBatis是一个优秀的Java持久层框架，它支持定制化SQL、存储过程以及高级映射。MyBatis避免了几乎所有的JDBC代码和手动设置参数以及获取结果集。MyBatis可以使用简单的XML或注解进行配置和原始映射，将接口和Java的...
MyBatis详解：spring和mybatis整合
2401_84153193的博客
05-03 1423
毕竟工作也这么久了 ，除了途虎一轮，也七七八八面试了不少大厂，像阿里、饿了么、美团、滴滴这些面试过程就不一一写在这篇文章上了。我会整理一份详细的面试过程及大家想知道的一些问题细节毕竟工作也这么久了 ，除了途虎一轮，也七七八八面试了不少大厂，像阿里、饿了么、美团、滴滴这些面试过程就不一一写在这篇文章上了。我会整理一份详细的面试过程及大家想知道的一些问题细节。
Mybatis详解
jhyy_cc的博客
02-01 2885
目录1.简介1.1 什么是Mybatis1.2 为什么需要Mybatis2、第一个Mybatis程序2.1 搭建环境2.2 创建一个模块2.3 编写代码2.4测试3、CRUD1、namespace2、select3、Insert4、update5、delete6、万能的Map7、模糊查询4、配置解析1、核心配置文件2、环境配置3、属性（properties）4、类型别名（typeAliases）5、设置6、其他配置7、映射器（mappers）8、作用域（Scope）和生命周期5、解决属性名和字段名不一致的问
myBatis详解
07-03
myBatis超详细配置流程,各种标签的详细介绍.包括XML核心配置详解,mapper映射配置详解,特殊符号详解,动态sql详解,多表查询,单表查询动态映射,....超详细
MyBatis入门到精通
02-28
MyBatis入门到精通，PDF，新手不错的学习资料。完整版的文档。
Mybatis从入门到精通
03-08
mybatis实战教程(mybatis in action)之一：开发环境搭建 .................................................. 3 mybatis实战教程(mybatis in action)之二：以接口的方式编程 .......................................... 8 mybatis实战教程(mybatis in action)之三:实现数据的增删改查 ....................................... 10 mybatis实战教程(mybatis in action)之四:实现关联数据的查询 ....................................... 14 mybatis实战教程(mybatis in action)之五:与spring3集成 ................................................. 18 mybatis实战教程(mybatis in action)之六:与Spring MVC 的集成 ..................................... 22 mybatis实战教程(mybatis in action)之七:实现mybatis分页 ............................................ 27 mybatis实战教程(mybatis in action)之八:mybatis 动态sql语句 ...................................... 36 mybatis实战教程(mybatis in action)之九:mybatis 代码生成工具的使用 ......................... 41
MyBatis从入门到精通__刘增辉电子工业出版社
01-16
本书中从一个简单的MyBatis查询入手，搭建起学习MyBatis的基础开发环境。通过全面的示例代码和测试讲解了在MyBatis XML方式和注解方式中进行增、删、改、查操作的基本用法，介绍了动态SQL在不同方面的应用以及在使用过程中的*实践方案。针对MyBatis高级映射、存储过程和类型处理器提供了丰富的示例，通过自下而上的方法使读者更好地理解和掌握MyBatis的高级用法，同时针对MyBatis的代码生成器提供了详细的配置介绍。此外，本书还提供了缓存配置、插件开发、Spring、Spring Boot集成的详细内容。*后通过介绍Git和GitHub让读者了解MyBatis开源项目
Mybatis从入门到精通（全）
码农研究僧的博客
07-08 4652
目录前言1. mybatis了解 前言 项目框架中 mybatis用于数据访问层 界面层：servlet–springmvc 业务逻辑层：service类–spring 数据访问层：dao类–mybatis 三层的访问交互是依次进行 在深入访问数据库后依次退出 而mybatis框架的好处对比 mybatis与jdbc、hibernate的对比： jdbc：代码比较多，开发效率低，重复代码多，业务代码和数据库操作混杂一起。在代码块中对象要创建和销毁，查询的结果要封装list。 hibernate：全自动 m
Mybatis 入门到精通
小炫风技术旅行
04-08 553
1. 引入依赖 mybatis依赖 &lt;dependency&gt; &lt;groupId&gt;org.mybatis.spring.boot&lt;/groupId&gt; &lt;artifactId&gt;mybatis-spring-boot-starter&lt;/artifactId&gt; &lt;version&gt;1.3.2&lt;/versio...
mybatis从入门到精通
weixin_45558236的博客
08-15 168
mybatis 1：创建步骤 引入mybatis的jar包和相关依赖(mysql,log4j,junit) 新建一个mybatis.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">
Spring AOP与Spring整合MyBatis详解
"qfedu关于Spring框架和Spring整合MyBatis的教程内容" 在Spring框架中，AOP（面向切面编程）是一个重要的核心功能，它允许开发者将系统中的非核心逻辑，如日志记录、事务管理等，抽取出来作为独立的模块，以切面的...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值