精华内容
下载资源
问答
  • mybatis框架

    2021-06-16 12:51:59
    1、讲解企业ORM框架的使用 2、讲解企业级主流的Mybatis框架综合应用 3、讲解使用mybatis完成数据库的各种操作
  • Mybatis框架

    2019-02-17 21:43:09
    mybatis是一个开源的持久化框架。里面有一个mybatis框架jar包和开发手册
  • MyBatis 框架

    千次阅读 多人点赞 2019-09-09 09:22:15
    二、IntelliJ IDEA使用MyBatis框架 1、mybatis的环境搭建(查询) 2、基于注解的 MyBatis 框架 3、插入数据 4、更新数据 5、删除数据 6、模糊查询 7、queryVo 查询 三、MyBatis 中的连接池和事务控制 1、...

    目录

    一、概述

    1、框架介绍

    2、三层架构

    3、MyBatis 框架简介

    二、IntelliJ IDEA使用MyBatis框架

    1、mybatis的环境搭建(查询)

    2、基于注解的 MyBatis 框架

    3、插入数据

    4、更新数据

    5、删除数据

    6、模糊查询

    7、queryVo 查询

    三、MyBatis 中的连接池和事务控制

    1、Mybatis 连接池的分类

    2、Mybatis 中数据源的配置

    3、Mybatis 中连接的获取过程分析 

    4、Mybatis 的事务控制

    四、Mybatis 的动态 SQL 语句

    1、 标签

    2、 标签

    3、 标签

    五、Mybatis 多表查询

    1、数据准备

    2、一对一查询(通过子类方式)

    3、一对一查询(通过建立实体类方式) 

    4、一对多查询


    一、概述

    1、框架介绍

    框架是我们使用软件开发中的一套解决方案,不同的框架能解决不同的问题,在框架中封装了很多的细节,使开发者可以使用极为简便的方式实现功能,大大的提升了开发的效率。

    2、三层架构

    • 表现层:用于展现数据
    • 业务层:用于处理业务需求
    • 持久层:用于和数据库交互

    3、MyBatis 框架简介

    mybatis是一个优秀的基于 java 的持久层框架,它内部封装了 jdbc,使开发者只需要关注 sql语句本身, 而不需要花费精力去处理加载驱动、创建连接、创建 statement 等繁杂的过程,它使用了ORM思想实现了结果集的封装。

    ORM:Object Relational Mapping(对象关系映射),即:把数据库表和实体类及实体类的属性对应起来,让开发人员可以操作实体类就可以实现对数据库表的操作

    二、IntelliJ IDEA使用MyBatis框架

    1、mybatis的环境搭建(查询)

    【1】前期准备

    在搭建之前先创建了mybatis数据库,并创建了user表,填入 id、username、birthday、sex、address 字段相关的数据

    【2】创建 maven 工程

    全部创建好后目录结构如下:

    从目录结构可以看到:

    • dao包下的IUserDao为dao接口
    • domain下的User类为实体类,是自己根据需求定义的javabean文件
    • resources下的SqlMapConfig.xml为mybatis的主配置文件
    • resources下的com.LSTAR.dao下的IUserDao.xml为映射配置文件
    • 最下面pom.xml为maven工程导入的坐标

    【3】导入坐标

    在 pom.xml 文件中添加 Mybatis3.4.5 坐标和相关坐标

    <?xml version="1.0" encoding="UTF-8"?>
    <project xmlns="http://maven.apache.org/POM/4.0.0"
             xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
             xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
        <modelVersion>4.0.0</modelVersion>
    
        <groupId>com.oneStar</groupId>
        <artifactId>oneMybatis</artifactId>
        <version>1.0-SNAPSHOT</version>
    
        <dependencies>
            <!--导入mybatis的jar包-->
            <dependency>
                <groupId>org.mybatis</groupId>
                <artifactId>mybatis</artifactId>
                <version>3.4.5</version>
            </dependency>
            <!--导入SQL相关jar包-->
            <dependency>
                <groupId>mysql</groupId>
                <artifactId>mysql-connector-java</artifactId>
                <version>5.1.32</version>
            </dependency>
            <!--导入日志相关jar包-->
            <dependency>
                <groupId>log4j</groupId>
                <artifactId>log4j</artifactId>
                <version>1.2.17</version>
            </dependency>
            <!--导入测试相关jar包-->
            <dependency>
                <groupId>junit</groupId>
                <artifactId>junit</artifactId>
                <version>4.12</version>
            </dependency>
        </dependencies>
    </project>

    【4】编写 User 实体类

    public class User {
        private Integer id;
        private String username;
        private Date birthday;
        private String sex;
        private String address;
    
        public Integer getId() {
            return id;
        }
    
        public void setId(Integer id) {
            this.id = id;
        }
    
        public String getUeername() {
            return username;
        }
    
        public void setUeername(String ueername) {
            this.username = ueername;
        }
    
        public Date getBirthday() {
            return birthday;
        }
    
        public void setBirthday(Date birthday) {
            this.birthday = birthday;
        }
    
        public String getSex() {
            return sex;
        }
    
        public void setSex(String sex) {
            this.sex = sex;
        }
    
        public String getAddress() {
            return address;
        }
    
        public void setAddress(String address) {
            this.address = address;
        }
    
        @Override
        public String toString() {
            return "User{" +
                    "id=" + id +
                    ", ueername='" + username + '\'' +
                    ", birthday=" + birthday +
                    ", sex='" + sex + '\'' +
                    ", address='" + address + '\'' +
                    '}';
        }
    }

     【5】编写持久层接口 IUserDao

    public interface IUserDao {
        /**
         * 查询所有操作
         * @return
         */
        List<User> findAll();
    }

     【6】编写持久层接口的映射文件 IUserDao.xml

    • 创建位置:必须和持久层接口在相同的包中
    • 名称:必须以持久层接口名称命名,拓展名为 .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.LSTAR.dao.IUserDao">
        <!--配置查询所有操作-->
        <select id="findAll">
            select * from user
        </select>
    </mapper>

    【7】创建 SqlMapConifg.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">
    <!--mybatis的主配置文件-->
    <configuration>
        <!--环境配置-->
        <environments default="mysql">
            <!--配置mysql的环境-->
            <environment id="mysql">
                <!--配置事务的类型-->
                <transactionManager type="JDBC"></transactionManager>
                <!--配置数据源(连接池)-->
                <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="123456"/>
                </dataSource>
            </environment>
        </environments>
        <!--指定映射配置文件的位置,映射配置文件指的是每个dao独立的配置文件-->
        <mappers>
            <mapper resource="com.LSTAR.dao.IUserDao.xml"/>
        </mappers>
    </configuration>

    【8】测试类

    Mybatis 在测试类中使用的模式:

    • SqlSessionFactory factory = builder.build(in);
      • 构建者模式:把对象的创建细节隐藏,使用者直接调用方法即可拿到对象
    • factory.openSession();
      • 工厂模式:降低了类之间的依赖关系
    • session.getMapper(IUserDao.class);
      • 代理模式:不改变源码的基础上对已有的方法进行增强
    public class mybatisTest {
        @Test
        public void Test() throws IOException {
            //1.读取配置文件
            InputStream in = Resources.getResourceAsStream("SqlMapConfig.xml");
            //2.创建 SqlSessionFactory 的构建者对象
            SqlSessionFactoryBuilder builder = new SqlSessionFactoryBuilder();
            //3.使用构建者创建工厂对象 SqlSessionFactory
            SqlSessionFactory factory = builder.build(in);
            //4.使用 SqlSessionFactory 生产 SqlSession 对象
            SqlSession session = factory.openSession();
            //5.使用 SqlSession 创建 dao 接口的代理对象
            IUserDao userDao = session.getMapper(IUserDao.class);
            //6.使用代理对象执行查询所有方法
            List<User> users = userDao.findAll();
            for(User user : users) {
                System.out.println(user);
            }
            //7.释放资源   session.close();
            in.close();
        }
    }

    注意事项

    • 在Mybatis中,会把持久层的操作接口名称和映射文件叫做:Mapper,IUserDao和IUserMapper是一样的
    • 在idea中创建目录的时候,如果要创建多级目录,需要一个一个目录创建,不能com.LSTAR.dao这样创建,否则是一个目录;创建包则可以这样创建
    • Mybatis的映射配置文件位置必须和dao接口的包结构相同
    • 映射配置文件的mapper标签namespace属性的取值必须是dao接口的全限定类名
    • 映射配置文件的操作配置(select),id属性的取值必须是dao接口的方法名

    2、基于注解的 MyBatis 框架

    【1】在持久层接口添加注解

    @Select("select * from user")

    public interface IUserDao {
        /**
         * 查询所有操作
         * @return
         */
        @Select("select * from user")
        List<User> findAll();
    }

    【2】修改 SqlMapConfig.xml 

    告知mybatis映射配置的位置

    <!--告知mybatis映射配置的位置-->
    <mappers>
        <mapper class="com.LSTAR.dao.IUserDao"/>
    </mappers>

    进行以上修改后可以将xml的映射配置(IUserDao.xml)给删除

    3、插入数据

    【1】在持久层接口添加 insertUser 方法

    /**
     * 插入数据
     * @param user
     */
    void insertUser(User user);

    【2】配置映射配置文件

    • parameterType属性:
      • 用于指定传入参数的类型,传入的是一个类的对象,所以写全类名
    • #{ } 字符:
      • 代表占位符,类似 jdbc 中的 ?,用于执行语句时替换实际的数据,由于我们保存方法的参数是 一个 User 对象,此处要写 User 对象中的属性名称。它用的是 ognl 表达式
    • ognl 表达式:
      • 它是 apache 提供的一种表达式语言,全称是:Object Graphic Navigation Language  对象图导航语言 
      • 语法格式就是使用  #{对象.对象}的方式 
      • #{user.username}它会先去找 user 对象,然后在 user 对象中找到 username 属性,并调用 getUsername()方法把值取出来。但是我们在 parameterType 属性上指定了实体类名称,所以可以省略 user. 而直接写 username
    <!--插入数据-->
    <insert id="insertUser" parameterType="com.LSTAR.domain.User">
        insert into user (username,address,sex,birthday)value(#{username},#{address},#{sex},#{birthday})
    </insert>

    【3】添加测试方法

    public class mybatisTest {
        private InputStream in;
        private SqlSession sqlSession;
        private IUserDao userDao;
        @Before     //用于在测试方法执行之前执行
        public void init() throws IOException {
            //1.读取配置文件
            in = Resources.getResourceAsStream("SqlMapConfig.xml");
            //2.创建 SqlSessionFactory 的构建者对象
            SqlSessionFactoryBuilder builder = new SqlSessionFactoryBuilder();
            //3.使用构建者创建工厂对象 SqlSessionFactory
            SqlSessionFactory factory = builder.build(in);
            //4.使用 SqlSessionFactory 生产 SqlSession 对象
            sqlSession = factory.openSession();
            //5.使用 SqlSession 创建 dao 接口的代理对象
            userDao = sqlSession.getMapper(IUserDao.class);
        }
        @After    //用于在测试方法执行之后执行
        public void destory() throws Exception {
            //释放资源   session.close();
            sqlSession.close();
            in.close();
        }
    
        /**
         * 查询所有数据测试
         * @throws IOException
         */
        @Test
        public void Test() throws IOException {
            //使用代理对象执行查询所有方法
            List<User> users = userDao.findAll();
            for(User user : users) {
                System.out.println(user);
            }
        }
    
        /**
         * 测试插入数据
         */
        @Test
        public void insertTest() throws IOException {
            User user = new User();
            user.setAddress("袁州区");
            user.setUsername("派大星");
            user.setSex("男");
            user.setBirthday(new Date());
            //使用代理对象执行插入方法
            userDao.insertUser(user);
            sqlSession.commit();
        }
    }

    4、更新数据

    【1】在持久层接口添加 updateUser 方法

    /**
     * 更新数据
     * @param user
     */
    void updateUser(User user);

    【2】配置映射配置文件

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

    【3】添加测试方法

    /**
     * 测试更新数据
     */
    @Test
    public void updateTest() throws IOException {
        User user = new User();
        user.setAddress("湘乡");
        user.setUsername("海绵宝宝");
        user.setSex("女");
        user.setBirthday(new Date());
        user.setId(41);
        //使用代理对象执行更新方法
        userDao.updateUser(user);
        sqlSession.commit();
    }

    5、删除数据

    【1】在持久层接口添加 deleteUser 方法

    /**
     * 删除数据
     * @param id
     */
    void deleteUser(Integer id);

    【2】配置映射配置文件

    <!--删除数据-->
    <delete id="deleteUser" parameterType="Integer">
        delete from user where id=#{id}
    </delete>

    【3】添加测试方法

    /**
     * 测试删除数据
     */
    @Test
    public void deleteTest() throws IOException {
        //使用代理对象执行更新方法
        userDao.deleteUser(42);
        sqlSession.commit();
    }

    6、模糊查询

    【1】在持久层接口添加 findByName 方法

    /**
     * 模糊查询
     * @param username
     */
    List<User> findByName(String username);

    【2】配置映射配置文件

    • resultType属性
      • 用于指定结果集的类型
    <!--模糊查询-->
    <select id="findByName" parameterType="String" resultType="com.LSTAR.domain.User">
        select * from user where username like #{username}
    </select>

    【3】添加测试方法

    /**
     * 模糊查询
     */
    @Test
    public void findByNameTest() throws IOException {
        //使用代理对象执行查询方法
        List<User> users = userDao.findByName("%星%");
        for(User user : users) {
            System.out.println(user);
        }
    }

    7、queryVo 查询

    【1】创建 QueryVo 类

    public class QueryVo implements Serializable {
        private User user;
    
        public User getUser() {
            return user;
        }
    
        public void setUser(User user) {
            this.user = user;
        }
    }

    【2】编写持久层接口

    /**
     *根据queryVo中的条件查询
     * @param vo
     * @return
     */
    List<User> findUserByVo(QueryVo vo);

    【3】配置映射配置文件

    <!--根据queryVo中的条件查询-->
    <select id="findUserByVo" parameterType="com.LSTAR.domain.QueryVo" resultType="com.LSTAR.domain.User">
        select * from user where username like #{user.username}
    </select>

    【4】添加测试方法

    /**
     * 根据queryVo中的条件查询
     */
    @Test
    public void findUserByVoTest() throws IOException {
        QueryVo vo = new QueryVo();
        User user = new User();
        user.setUsername("%宝%");
        vo.setUser(user);
        //使用代理对象执行查询方法
        List<User> users = userDao.findUserByVo(vo);
        for(User u : users) {
            System.out.println(u);
        }
    }

    三、MyBatis 中的连接池和事务控制

    Mybatis 连接池采用的是自己的连接池技术,在 Mybatis 的 SQLMapConfig.xml 配置文件中,通过 <dataSource type="pooled"> 来实现 Mybatis 中连接池的配置。

    1、Mybatis 连接池的分类

     Mybatis 将它自己的数据源 DataSource 分为三类: 

    • UNPOOLED:不使用连接池的数据源
    • POOLED:使用连接池的数据源
    • JNDI:使用 JNDI 实现的数据源

    相应地,MyBatis 内部分别定义了实现了 java.sql.DataSource 接口的 UnpooledDataSource, PooledDataSource 类来表示 UNPOOLED、POOLED 类型的数据源。 

    在这三种数据源中,我们一般采用的是 POOLED 数据源(很多时候我们所说的数据源就是为了更好的管理数据 库连接,也就是我们所说的连接池技术)。 

    2、Mybatis 中数据源的配置

    在 SqlMapConfig.xml 文件中,具体配置如下: 

    <!--配置数据源(连接池)-->
    <dataSource type="POOLED">
        <!-- 配置连接数据库的4个基本信息 -->
        <property name="driver" value="com.mysql.jdbc.Driver"/>
        <property name="url" value="jdbc:mysql://localhost:3306/mybatise"/>
        <property name="username" value="root"/>
        <property name="password" value="123456"/>
    </dataSource>

    MyBatis 在初始化时,根据<dataSource>的 type 属性来创建相应类型的的数据源 DataSource,即:

    • type=”POOLED”:MyBatis 会创建 PooledDataSource 实例
    • type=”UNPOOLED” : MyBatis 会创建 UnpooledDataSource 实例
    • type=”JNDI”:MyBatis 会从 JNDI 服务上查找 DataSource 实例,然后返回使用 

    3、Mybatis 中连接的获取过程分析 

    当我们需要创建 SqlSession 对象并需要执行 SQL 语句时,这时候 MyBatis 才会去调用 dataSource 对象 来创建java.sql.Connection对象。也就是说,java.sql.Connection对象的创建一直延迟到执行SQL语句 的时候。

    只有当第 4句sqlSession.selectList("findUserById"),才会触发MyBatis 在底层执行下面这个方 法来创建 java.sql.Connection 对象。

    只有在要用到的时候,才去获取并打开连接,当我们用完了就再 立即将数据库连接归还到连接池中。 

    @Test 
    public void testSql() throws Exception {  
        InputStream in = Resources.getResourceAsStream("SqlMapConfig.xml");  
        SqlSessionFactory factory = new SqlSessionFactoryBuilder().build(in);  
        SqlSession sqlSession = factory.openSession();  
        List<User> list = sqlSession.selectList("findUserById",41);                  
        System.out.println(list.size()); 
    } 

    4、Mybatis 的事务控制

    Mybatis 框架因为是对 JDBC 的封装,所以 Mybatis 框架的事务控制方式,本身也是用 JDBC的 setAutoCommit()方法来设置事务提交方式的。 

    【1】手动提交事务

    /**
     * 测试插入数据
     */
    @Test
    public void insertTest() throws IOException {
        User user = new User();
        user.setAddress("袁州区");
        user.setUsername("派大星");
        user.setSex("男");
        user.setBirthday(new Date());
        //使用代理对象执行插入方法
        userDao.insertUser(user);
        //手动提交事务
        sqlSession.commit();
    }
    

    使用 sqlSession.commit(); 手动提交事务,并且在控制台会有提交事务的打印信息,原因是 setAutoCommit()方法,在执行时它的值被设置为 false 了,所以我们在 CUD 操作中, 必须通过 sqlSession.commit()方法来执行提交操作。

    【2】自动提交事务

    使用 sqlSession.commit()提交事务,是因为在连接池中取出的连接,都会将调用 connection.setAutoCommit(false)方法,这样我们就必须使用 sqlSession.commit()方法,相当于使用了 JDBC 中的 connection.commit() 方法实现事务提交。

    也可以设置自动提交事务,只需在创建 SqlSession 对象时设置参数为 true 即可:

    @Before     //用于在测试方法执行之前执行
    public void init() throws IOException {
        //1.读取配置文件
        in = Resources.getResourceAsStream("SqlMapConfig.xml");
        //2.创建 SqlSessionFactory 的构建者对象
        SqlSessionFactoryBuilder builder = new SqlSessionFactoryBuilder();
        //3.使用构建者创建工厂对象 SqlSessionFactory
        SqlSessionFactory factory = builder.build(in);
        //4.使用 SqlSessionFactory 生产 SqlSession 对象
        sqlSession = factory.openSession(true);
        //5.使用 SqlSession 创建 dao 接口的代理对象
        userDao = sqlSession.getMapper(IUserDao.class);
    }

    四、Mybatis 的动态 SQL 语句

    1、<if> 标签

    【1】编写持久层接口

    /**
     * 根据条件查询
     * @param user:查询的条件
     * @return
     */
    List<User> findByCondition(User user);

    【2】持久层映射配置

    <!--根据条件查询  if标签-->
    <select id="findByCondition" resultType="com.LSTAR.domain.User" parameterType="com.LSTAR.domain.User">
        select * from user where 1=1
        <if test="username != null">
            and username = #{username}
        </if>
    </select>

    【3】测试类

    /**
     * 根据条件查询
     */
    @Test
    public void findByContion(){
        User u = new User();
        u.setUsername("派大星");
        List<User> users = userDao.findByCondition(u);
        for(User user : users){
            System.out.println(user);
        }
    }

    2、<where> 标签

    在<标签>中, where 1=1 表示的是永远为真,为了简化这个条件封装,可以采用 <where> 标签来进行简化

    持久层映射配置

    <select id="findByCondition" resultType="com.LSTAR.domain.User" parameterType="com.LSTAR.domain.User">
        select * from user
        <where>
            <if test="username != null">
                and username = #{username}
            </if>
        </where>
    </select>

    3、<foreach> 标签

      【1】在 QueryVo 中加入一个 List 集合用于封装参数 

    public class QueryVo implements Serializable {
        private List<Integer>  ids;
    
        public List<Integer> getIds() {
            return ids;
        }
    
        public void setIds(List<Integer> ids) {
            this.ids = ids;
        }
    }

    【2】持久层映射配置

    • <foreach>:用于遍历集合,属性:
      • collection:代表要遍历的集合元素
      • open:代表语句的开始部分
      • close:代表结束部分
      • item:代表遍历集合的每个元素,生成的变量名
      • sperator:代表分隔符
    <!--根据id集合查询用户-->
    <select id="findByIds" parameterType="com.LSTAR.domain.QueryVo" resultType="com.LSTAR.domain.User">
        select * from user
        <where>
            <if test="ids != null and ids.size() > 0">
                <foreach collection="ids" open="and id in (" close=")" item="id"  separator=",">
                    #{id}
                </foreach>
            </if>
        </where>
    </select>

    【3】测试类

    /**
     * 根据queryVo中的id集合条件查询
     */
    @Test
    public void findByIdsTest() throws IOException {
        QueryVo vo = new QueryVo();
        List<Integer> list = new ArrayList<Integer>();
        list.add(41);
        list.add(43);
        list.add(49);
        vo.setIds(list);
        //使用代理对象执行查询方法
        List<User> users = userDao.findByIds(vo);
        for(User u : users) {
            System.out.println(u);
        }
    }

    五、Mybatis 多表查询

    1、数据准备

    实现多表查询,这里创建两张表,一个是用户表,一个是账户表,使用外键让用户表和账户表之间具备一对多的关系,并建立用户和账户的实体类

    【1】创建 mybatise 数据库

    创建好数据库后并创建 user 数据表和 account 数据表,并插入相关数据

    CREATE TABLE `user` (
      `id` int(11) NOT NULL auto_increment,
      `username` varchar(32) NOT NULL COMMENT '用户名称',
      `birthday` datetime default NULL COMMENT '生日',
      `sex` char(1) default NULL COMMENT '性别',
      `address` varchar(256) default NULL COMMENT '地址',
      PRIMARY KEY  (`id`)
    ) ENGINE=InnoDB DEFAULT CHARSET=utf8;
    CREATE TABLE `account` (
      `ID` int(11) NOT NULL COMMENT '编号',
      `UID` int(11) default NULL COMMENT '用户编号',
      `MONEY` double default NULL COMMENT '金额',
      PRIMARY KEY  (`ID`),
      KEY `FK_Reference_8` (`UID`),
      CONSTRAINT `FK_Reference_8` FOREIGN KEY (`UID`) REFERENCES `user` (`id`)
    ) ENGINE=InnoDB DEFAULT CHARSET=utf8;

    【2】创建实体类

    创建用户实体类和账户实体类

    public class User implements Serializable{
    
        private Integer id;
        private String username;
        private Date birthday;
        private String sex;
        private String address;
    
        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 Date getBirthday() {
            return birthday;
        }
    
        public void setBirthday(Date birthday) {
            this.birthday = birthday;
        }
    
        public String getSex() {
            return sex;
        }
    
        public void setSex(String sex) {
            this.sex = sex;
        }
    
        public String getAddress() {
            return address;
        }
    
        public void setAddress(String address) {
            this.address = address;
        }
    
        @Override
        public String toString() {
            return "User{" +
                    "id=" + id +
                    ", username='" + username + '\'' +
                    ", birthday=" + birthday +
                    ", sex='" + sex + '\'' +
                    ", address='" + address + '\'' +
                    '}';
        }
    }
    public class Account implements Serializable {
    
        private Integer id;
        private Integer uid;
        private Double money;
    
        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 getUid() {
            return uid;
        }
    
        public void setUid(Integer uid) {
            this.uid = uid;
        }
    
        public Double getMoney() {
            return money;
        }
    
        public void setMoney(Double money) {
            this.money = money;
        }
    
        @Override
        public String toString() {
            return "Account{" +
                    "id=" + id +
                    ", uid=" + uid +
                    ", money=" + money +
                    '}';
        }
    }

    【3】编写持久层接口

    public interface IAccountDao {
    
        /**
         * 查询所有账户,同时还要获取到当前账户的所属用户信息
         * @return
         */
        List<Account> findAll();
    }
    
    
    public interface IUserDao {
    
        /**
         * 查询所有用户,同时获取到用户下所有账户的信息
         * @return
         */
        List<User> findAll();
    }

    2、一对一查询(通过子类方式)

    eg:现要实现查询所有账户信息,同时还要获取到当前账户的所属用户的用户名和地址信息

    【1】定义 AccountUser 类

    为了能够封装上面 SQL 语句的查询结果,定义 AccountCustomer 类中要包含账户信息同时还要包含用户信 息,所以我们要在定义 AccountUser 类时可以继承 User 类。 

    public class AccountUser extends Account {
    
        private String username;
        private String address;
    
        public String getUsername() {
            return username;
        }
    
        public void setUsername(String username) {
            this.username = username;
        }
    
        public String getAddress() {
            return address;
        }
    
        public void setAddress(String address) {
            this.address = address;
        }
    
        @Override
        public String toString() {
            return super.toString()+"        AccountUser{" +
                    "username='" + username + '\'' +
                    ", address='" + address + '\'' +
                    '}';
        }
    }

    【2】编写持久层接口

    /**
     * 查询所有账户,并且带有用户名称和地址信息
     * @return
     */
    List<AccountUser> findAllAccount();

    【3】持久层映射配置

    <?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.itheima.dao.IUserDao">
        <!-- 查询所有 -->
        <select id="findAll" resultMap="userAccountMap">
            select a.*,u.username,u.address from account a,user u where a.uid =u.id; 
        </select>
    </mapper>

     【4】测试类

    /**
     * 测试查询所有账户,同时包含用户名称和地址
     */
    @Test
    public void testFindAllAccountUser(){
        List<AccountUser> aus = accountDao.findAllAccount();
        for(AccountUser au : aus){
            System.out.println(au);
        }
    }

    3、一对一查询(通过建立实体类方式) 

    通过建立实体类的方式,使用 resultMap,定义专门的 resultMap 用于映射一对一查询结果,所以可以在 Account 类中加入 User 类的对象作为 Account 类的一个属性。

    【1】修改 Account 类

    在 Account 类中添加以下属性:

    //从表实体应该包含一个主表实体的对象引用
    private User user;
    
    public User getUser() {
        return user;
    }
    
    public void setUser(User user) {
        this.user = user;
    }

     【2】修改 AccountDao 接口中的方法

    将返回对象改为 Account 类型,因为 Account 类中包含了一个 User 类的对象,它可以封装账户所对应的用户信息

    /** 
    * 查询所有账户,同时获取账户的所属用户名称以及它的地址信息   
    * @return   
    */  
    List<Account> findAll(); 

     【3】重新定义 AccountDao.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.itheima.dao.IAccountDao">
    
        <!-- 定义封装account和user的resultMap -->
        <resultMap id="accountUserMap" type="account">
            <id property="id" column="aid"></id>
            <result property="uid" column="uid"></result>
            <result property="money" column="money"></result>
            <!-- 一对一的关系映射:配置封装user的内容-->
            <association property="user" column="uid" javaType="user">
                <id property="id" column="id"></id>
                <result column="username" property="username"></result>
                <result column="address" property="address"></result>
                <result column="sex" property="sex"></result>
                <result column="birthday" property="birthday"></result>
            </association>
        </resultMap>
    
        <!-- 查询所有 -->
        <select id="findAll" resultMap="accountUserMap">
            select u.*,a.id as aid,a.uid,a.money from account a , user u where u.id = a.uid;
        </select>
    
        <!--查询所有账户同时包含用户名和地址信息-->
        <select id="findAllAccount" resultType="accountuser">
            select a.*,u.username,u.address from account a , user u where u.id = a.uid;
        </select>
    </mapper>

    【4】测试类

    /**
     * 测试查询所有
     */
    @Test
    public void testFindAll(){
        List<Account> accounts = accountDao.findAll();
        for(Account account : accounts){
            System.out.println("--------每个account的信息------------");
            System.out.println(account);
            System.out.println(account.getUser());
        }
    }

    4、一对多查询

    要实现查询所有用户信息以及用户关联的账户信息,即一对多查询,在查询过程中,如果用户没有账户信息,此时也要将用户信息查询出来,可以使用左外键连接查询。

    【1】User类中添加List<Account>

    //一对多关系映射:主表实体应该包含从表实体的集合引用
    private List<Account> accounts;
    
    public List<Account> getAccounts() {
        return accounts;
    }
    
    public void setAccounts(List<Account> accounts) {
        this.accounts = accounts;
    }

    【2】编写持久层接口

    /**
     * 查询所有用户,同时获取到用户下所有账户的信息
     * @return
     */
    List<User> findAll();

    【3】持久层映射配置

    • collection标签:部分定义了用户关联的账户信息,表示关联查询结果集,属性有:
      • property="accList":关联查询的结果集存储在 User 对象上哪个属性
      • ofType="account":指定关联查询的结果集中的对象类型即 List 中的对象类型,此处可以使用别名,也可以使用全类名
    <?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.itheima.dao.IUserDao">
    
        <!-- 定义User的resultMap-->
        <resultMap id="userAccountMap" type="user">
            <id property="id" column="id"></id>
            <result property="username" column="username"></result>
            <result property="address" column="address"></result>
            <result property="sex" column="sex"></result>
            <result property="birthday" column="birthday"></result>
            <!-- 配置user对象中accounts集合的映射 -->
            <collection property="accounts" ofType="account">
                <id column="aid" property="id"></id>
                <result column="uid" property="uid"></result>
                <result column="money" property="money"></result>
            </collection>
        </resultMap>
    
        <!-- 查询所有 -->
        <select id="findAll" resultMap="userAccountMap">
            select * from user u left outer join account a on u.id = a.uid
        </select>
    
        <!-- 根据id查询用户 -->
        <select id="findById" parameterType="INT" resultType="user">
            select * from user where id = #{uid}
        </select>
    </mapper>

    【4】测试类

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

     


    展开全文
  • Spring+SpringMVC+Mybatis框架整合例子(SSM) 下载

    万次下载 热门讨论 2014-07-21 12:06:07
    本资源对应博文:http://blog.csdn.net/zhshulin/article/details/37956105,可以通过博文进行学习,不建议下载完整源码,博文有详细教程,以及代码。
  • Mybatis 框架(一)—— Mybatis 简介、MyBatis 框架搭建

    千次阅读 多人点赞 2020-03-04 09:25:45
    文章目录一、Mybatis 简介1、Mybatis 概述2、Mybatis的优势:二、MyBatis 框架搭建 一、Mybatis 简介 1、Mybatis 概述 MyBatis 原名 ibatis 是 Apache 的一款开源框架,后来更名为 MybatisMybatis 是一款优秀的...

    一、Mybatis 简介

    1、Mybatis 概述

    • MyBatis 原名 ibatis 是 Apache 的一款开源框架,后来更名为 Mybatis。
    • Mybatis 是一款优秀的持久层框架,它支持定制化 SQL、存储过程以及高级映射。
    • MyBatis 避免了几乎所有的 JDBC 代码和手动设置参数以及获取结果集。
    • MyBatis 可以使用简单的 XML注解来配置和映射ORM信息,将Java的实体类对象映射成数据库中的记录。

    2、Mybatis的优势:

    (1)简单易学:本身就很小且简单。没有任何第三方依赖,最简单安装只要两个jar文件+配置几个sql映射文件,易于学习,易于使用,通过文档和源代码,可以比较完全的掌握它的设计思路和实现。
    (2)灵活:mybatis 不会对应用程序或者数据库的现有设计强加任何影响。 sql 写在 xml 里,便于统一管理和优化。通过 sql 语句可以满足操作数据库的所有需求。
    (3)解除 sql 与程序代码的耦合:通过提供 DAO 层,将业务逻辑和数据访问逻辑分离,使系统的设计更清晰,更易维护,更易单元测试。sql 和代码的分离,提高了可维护性。
    (4)提供映射标签,支持对象与数据库的 orm 字段关系映射。
    (5)提供对象关系映射标签,支持对象关系组建维护。
    (6)提供 xml 标签,支持编写动态sql。

    二、MyBatis 框架搭建

    (1)获取 Mybatis 开发包
    Mybatis 的下载地址为https://github.com/mybatis/mybatis-3/releases,下载好之后解压的目录结构如下:
    在这里插入图片描述
    mybatis 的jar包只有一个,就是图中的 mybatis-3.4.6.jar,后期如果要整合 spring 框架需要额外导入一个 mybatis-spring 的插件包。lib文件夹中是 mybatis 有可能使用到的第三方工具包。pdf文件是官方提供的英文版开发文档。

    (2)新建项目导入 jdbc 驱动包和 mybatis 的 mybatis-3.4.6.jar 包

    (3)在 src 目录下新建mybatis-config.xml(名字任取)文件,该文件是 mybatis 的核心配置文件,用于配置数据库连接信息以及 mybatis 的一些属性设置。同样的在编写该 xml 文件时,需要引入 dtd 验证,该 dtd 在 jar 包里面是没有提供的,只能去开发文档中找。

    <?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="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/test?useUnicode=true&amp;characterEncoding=utf-8" />
    				<property name="username" value="root" />
    				<property name="password" value="123456" />
    	        </dataSource>
    	    </environment>
    	</environments>
    </configuration>
    

    标签作用:

    • configuration:根标签
    • environments:配置 jdbc 连接的数据库环境,default 属性表示默认使用的环境
    • environment:配置一种 jdbc 连接的数据库环境,id 属性表示该环境的名称,在 environments 标签的 default 中使用该id的值来默认选择使用该数据库环境
    • dataSource:配置数据源,type="POOLED"表示会使用 mybatis 自己创建的连接池来获取连接
    • property:配置数据源的各项连接信息

    (4)创建测试类,测试是否能够获取 mybatis 提供的数据库连接对象

    try {
    	//加载配置文件获取输入流对象
    	InputStream is = Resources.getResourceAsStream("Mybatis1.xml");
    	//通过输入流对象中的信息获取SqlSessionFactory
    	SqlSessionFactory factory = new SqlSessionFactoryBuilder().build(is);
    	//通过SqlSessionFactory获取SqlSession对象
    	SqlSession session = factory.openSession();
    	System.out.println(session);
    } catch (IOException e) {
    	e.printStackTrace();
    }
    

    为了便于管理数据库的配置信息,我们可以 jdbc 连接信息保存在一个资源文件中,然后使用资源文件中的数据来配置数据库连接信息.
    ① 在 src 下新建资源文件jdbc.properties

    #jdbc连接信息
    jdbc.driverClass=com.mysql.jdbc.Driver
    jdbc.jdbcUrl=jdbc:mysql://localhost:3306/test?useUnicode=true&characterEncoding=utf-8
    jdbc.user=root
    jdbc.password=admin
    #c3p0连接信息
    c3p0.minPoolSize=10
    c3p0.maxPoolSize=50
    c3p0.initialPoolSize=20
    c3p0.maxIdleTime=60
    c3p0.acquireIncrement=1
    c3p0.checkoutTimeout=6000
    c3p0.idleConnectionTestPeriod=600
    

    ② 在mybatis-config.xml中加载资源文件,然后使用EL表达式从资源文件中取值并使用,在 configuration 标签中使用 properties 标签引入资源文件:

    <properties resource="jdbc.properties"></properties>
    

    ③ 修改数据源配置:

    <dataSource type="POOLED">
    	<property name="driver" value="${jdbc.driverClass}" />
    	<property name="url" value="${jdbc.jdbcUrl}" />
    	<property name="username" value="${jdbc.user}" />
    	<property name="password" value="${jdbc.password}" />
    </dataSource>
    

    (5)Mybatis 在设计时采用了动态代理模式,我们在使用 mybatis 实现增删改查时,只需要提供数据层接口和该接口对应的映射文件,映射文件中要针对数据层接口中的每一个方法提供对应的sql语句、参数类型、返回值类型等信息,最终 mybatis 会创建动态代理对象实现数据层接口,而动态代理中的方法会执行映射文件中对应的SQL语句。
    在这里插入图片描述
    上图中表示的是数据层接口与映射文件的对应关系,要求:

    • 映射文件的namespace必须等于数据层接口名称(全限定名称)
    • 映射文件中标签的id必须等于数据层接口方法的名称
    • 根据上述的要求,在项目中定义数据层接口和映射文件

    (6)创建实体类
    mybatis 作为ORM框架一定具备对象关系映射的能力,mybatis 在循环结果集封装实体类对象时默认会将数据封装到和字段名称相同的属性中,所以我们在建实体类时尽量保证实体类属性名称和数据库表的字段名称一致,这样做可以减少很多不必要的配置。

    public class Products {
    	private int p_id;
    	private String p_name;
    	private double p_price;
    	private int p_count;
    	//省略get、set和toString方法
    }
    

    (7)创建数据层接口

    public interface SelectMapper {
    	public List<Products> select();
    }
    

    (8)创建数据层接口映射文件SelectMapper.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.mybatis.demo1.dao.SelectMapper">
       <select id="select" resultType="com.mybatis.demo1.entity.Products" >
           select * from products
       </select>
    </mapper>
    

    在数据层接口映射文件中同样要引入DTD文件,标签的用途如下:

    • mapper:根标签,namespace属性一定要和该映射文件对应的数据层接口名称一致。
    • 针对于数据层接口中的增删改查方法,mybatis 提供了4种标签进行映射,分别是select、insert、update、delete,这4种标签的id必须和查询方法的方法名一致,resultType表示 mybatis 在遍历结果集时封装的实体类类型,parameterType表示该方法的参数类型,标签之间的内容用来写 sql 语句以及一些其他的标签(动态sql)。
    • select:与查询方法对应的标签
    • insert:与新增方法对应的标签
    • update:与更新方法对应的标签
    • delete:与删除方法对应的标签

    (9)做完上述配置以后,一定要在mybatis-config.xml文件中将映射文件地址添加进去,有三种方式。
    ① 方式1:

    <mappers>
       <mapper resource="com/mybatis/demo1/dao/SelectMapper.xml"/>
    </mappers>
    

    ② 方式2:通过数据层接口来引入映射文件

    <mappers>
       <mapper class="com.mybatis.demo1.dao.SelectMapper"/>
    </mappers>
    

    ③ 方式3:引入某个包下的所有的数据接口,要求数据层接口名称和映射文件名称一致

    <mappers>
       <package name="com.mybatis.demo1.dao" />
    </mappers>
    

    (10)通过 SqlSession 对象创建数据层接口的动态代理对象,并执行方法。

    public class Test {
    	public static void main(String[] args) {
    		try {
    			//加载配置文件获取输入流对象
    			InputStream is = Resources.getResourceAsStream("Mybatis1.xml");
    			//通过输入流对象中的信息获取SqlSessionFactory
    			SqlSessionFactory factory = new SqlSessionFactoryBuilder().build(is);
    			//通过SqlSessionFactory获取SqlSession对象
    			SqlSession session = factory.openSession();
    			
    			SelectMapper mapper = session.getMapper(SelectMapper.class);
    			List<Products> list = mapper.select();
    			System.out.println(list);
    		} catch (IOException e) {
    			e.printStackTrace();
    		}
    	}
    }
    
    展开全文
  • mybatis框架笔记

    2017-10-17 11:33:00
    SSM的mybatis框架笔记,简介mybatis框架的历史,开发步骤等等
  • Mybatis框架 |Mybatis框架介绍

    千次阅读 多人点赞 2020-02-06 19:52:05
    一个JDBC编码例子2.JDBC编码问题分析二、持久层框架1.Hibernate2.Mybaties三、MyBatis优缺点1.优点2.缺点 一、Mybaties介绍 MyBatis 本是apache的一个开源项目iBatis, 2010年这个项目由apache迁移到了Google,并且...


    一、为什么弃用JDBC?

    1.一个JDBC编码例子

    一个JavaWeb中连接数据库的代码如下:

    /**
     * 类说明:
     * 		JDBC创建PreparedStatement对象连接数据库
     * @author qianliangguo
     */
    public class testPreparedStatement {
    	public static void main(String[] args) {
    		Connection conn = null;
    		PreparedStatement pstm = null;
    		ResultSet rs = null;
    		try {
    			// 1.加载驱动
    			Class.forName("com.mysql.jdbc.Driver");
    			// 2.获取连接
    			String url = "jdbc:mysql://localhost:3306/mybase?useUnicode=true&characterEncoding=utf-8";
    			String user = "root";
    			String password = "Hudie";
    			conn = DriverManager.getConnection(url, user, password);
    			// 3.创建PreparedStatement,预编译sql语句
    			String sql = "select * from emp where job=?";
    			pstm = conn.prepareStatement(sql);//创建sql半成品
    			pstm.setString(1,"clerk");//参数绑定
    			//4.执行sql语句
    			rs = pstm.executeQuery();
    			//5.处理结果集
    			while(rs.next()){
    				int empno = rs.getInt("empno");
    				String ename = rs.getString("ename");
    				String job = rs.getString(3);
    				int mgr = rs.getInt("mgr");
    				Date hiredate = rs.getDate(5);
    				double sal = rs.getDouble("sal");
    				double comm = rs.getDouble("commit");
    				int deptno = rs.getInt(8);
    				System.out.println(empno+" "+ename+" "+job+" "+mgr+" "+hiredate+" "+sal+" "+comm+" "+deptno);
    			}
    		} catch (Exception e) {
    			e.printStackTrace();
    		} finally {
    			// 6.关闭连接/释放资源
    			try {
    				rs.close();
    				pstm.close();
    				conn.close();
    			} catch (SQLException e) {
    				e.printStackTrace();
    			}
    		}
    	}
    }
    

    2.JDBC编码问题分析

    可以看到,上面的代码相当复杂,主要有下面几个大的问题,框架的出现很好的解决了这些问题。

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

    • Sql 语句在代码中硬编码,造成代码不易维护,实际应用 sql 变化的可能较大,sql 变动需要改变 java代码。
      解决方案:把sql语句写在一个配置文件中,修改配置文件中的sql语句就行了。

    • 使用 preparedStatement 向占有位符号传参数存在硬编码,因为 sql 语句的 where 条件不一定,可能多也可能少,修改 sql 还要修改代码,系统不易维护。
      解决方案:sql语句中的占位符及其参数写在一个配置文件中,自动的完成参数的输入。(输入映射)

    • 结果集解析存在硬编码(查询列名),sql 变化导致解析代码变化,系统不易维护,如果能将数据库记录封装成 pojo 对象解析比较方便。
      解决方案:查询的结果和Java对象可以自动完成映射。(输出映射)

    二、主流的持久层框架

    Mybatis属于SQL映射框架;而Hibernate属于ORM框架。

    1.Hibernate框架

    Hibernate是一个全自动ORM(Object Relation Mapping),旨在消除sql。但这也是把双刃剑,直接造成了herbinate的优化成本高,因为其无法支持定制化sql。

    • Hibernate由于过于强大,把过多的工作都进行了黑箱操作,当业务逻辑过于复杂时,很难支持定制化sql就成了硬伤。
      在这里插入图片描述

    2.Mybatis框架(主流)

    MyBatis 是一款优秀的持久层框架。支持定制化 SQL、存储过程以及高级映射;避免了几乎所有的 JDBC 代码和手工设置参数以及抽取结果集。MyBatis 使用简单的 XML 或注解来配置和映射原生信息,将接口和 Java 的 POJOs(Plain Old Java Objects,普通的 Java对象)映射成数据库中的记录。

    Mybatis封装了JDBC的很多细节,使开发者只需要关注sql语句本身,无需关注注册驱动,创建连接等繁杂过程。使用了ORM思想实现了结果集的封装。

    Mybatis框架的特点

    • sql语句与代码分离,存放于xml配置文件中。
      优:解除sql与程序代码的耦合,便于维护管理。
      缺:降低了代码可读性,而且不利于调试。

    • 查询的结果集与java对象自动映射。
      优:保证名称相同,配置好映射关系即可自动映射;不配置映射关系,通过配置列名=字段名也可完成自动映射。
      缺:对开发人员所写的SQL依赖很强。

    • 需编写原生SQL
      优:接近JDBC,比较灵活。
      缺:对SQL语句依赖程度很高,并且数据库移植比较麻烦。

    在这里插入图片描述

    展开全文
  • mybatis框架练习

    2018-11-01 09:14:32
    mybatis框架练习,适合初学者练习学习和参考。。
  • JavaEE SpringMVC MyBatis框架例子JavaEE SpringMVC MyBatis框架例子JavaEE SpringMVC MyBatis框架例子JavaEE SpringMVC MyBatis框架例子JavaEE SpringMVC MyBatis框架例子JavaEE SpringMVC MyBatis框架例子JavaEE ...
  • JavaEE Spring MyBatis框架(登录)JavaEE Spring MyBatis框架(登录)JavaEE Spring MyBatis框架(登录)JavaEE Spring MyBatis框架(登录)JavaEE Spring MyBatis框架(登录)JavaEE Spring MyBatis框架(登录)JavaEE Spring ...
  • mybatis 框架视频

    2019-01-14 11:20:14
    mybatis 框架开发视频,百度云分享,此链接永久有效,如果失效请联系我!
  • MyBatis框架简介

    2020-08-31 02:54:19
    本文主要介绍了MyBatis框架的基础知识。具有很好的参考价值。下面跟着小编一起来看下吧
  • mybatis框架代码

    2016-11-20 15:49:06
    mybatis框架代码
  • JavaEE MyBatis框架入门

    2018-11-20 16:54:38
    JavaEE MyBatis框架入门 里面详细介绍了 MyBatis框架连接数据库 实现增删改查的代码案例 仅供初学者学习
  • mybatis框架详解

    2018-06-12 13:21:00
    主要讲解的是mybatis框架 并结合springmvc、 spring两大框架整合应用,使读者能更够清晰更全面的认识mybatis
  • 本人博客文章《mybatis框架-学习笔记Day01》的相关代码文件本人博客文章《mybatis框架-学习笔记Day01》的相关代码文件本人博客文章《mybatis框架-学习笔记Day01》的相关代码文件本人博客文章《mybatis框架-学习笔记...
  • JavaEE 框架篇二 MyBatis框架
  • Mybatis框架整体巩固

    2017-08-05 08:50:25
    Mybatis框架整体巩固笔记
  • MyBatis是一个支持普通SQL查询,存储过程和高级映射的优秀持久层框架。这篇文章主要介绍了mybatis框架入门学习教程,需要的朋友可以参考下

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 206,932
精华内容 82,772
关键字:

mybatis框架