AI 助理
备案控制台
开发者社区 开发与运维 文章 正文

MyBatis 学习笔记（一）MyBatis的简介与使用以及与其他ORM框架的比较

2023-01-31 302
版权
版权声明：
本文内容由阿里云实名注册用户自发贡献，版权归原作者所有，阿里云开发者社区不拥有其著作权，亦不承担相应法律责任。具体规则请查看《 阿里云开发者社区用户服务协议》和 《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容，填写 侵权投诉表单进行举报，一经查实，本社区将立刻删除涉嫌侵权内容。
本文涉及的产品
RDS MySQL Serverless 基础系列，0.5-2RCU 50GB
推荐场景：
学生管理系统数据库设计 搭建个人博客
云数据库 RDS PostgreSQL，高可用系列 2核4GB
RDS MySQL Serverless 高可用系列，价值2615元额度，1个月
简介： MyBatis 前身是Apache基金会的开源项目iBatis，在2010年该项目脱离Apache基金会并正式更名为MyBatis，在2013年11月，MyBatis迁移到了GitHub。

什么是MyBatis

MyBatis 前身是Apache基金会的开源项目iBatis，在2010年该项目脱离Apache基金会并正式更名为MyBatis，在2013年11月，MyBatis迁移到了GitHub。

MyBatis 是一个轻量级的，半自动的持久化（ORM）框架， 其通过XML映射配置文件或者注解来配置和映射原生类型，接口和Java的POJO（Plain Old Java Objects,普通老式Java对象）为数据库中的记录。之所以是半自动化的框架，是因为其不能像Hibernate一样实现自动生成SQL，其需要用户手动编写SQL语句。方便用户对SQL语句进行优化，适用于大数据量，高并发场景。

MyBatis 是一块比较容易上手的框架，使用者只需要通过简单的学习即可掌握其常用特性。

为什么要使用MyBatis

使用MyBatis访问数据库

 <dependency>
            <groupId>org.mybatis</groupId>
            <artifactId>mybatis</artifactId>
            <version>3.4.5</version>
        </dependency>

正如前面所说MyBatis 是一个半自动持久化框架。所以，需要我们自己来维护sql 语句，编写sql语句的xml文件叫做映射文件。在此处，我建立了一个StudentMapper.xml 文件来维护sql 语句。

<mapper namespace="com.jay.mapper.StudentMapper">
    <resultMap id="BaseColumn" type="com.jay.entity.Student">
        <id property="id" column="id"/>
        <result property="name" column="name"/>
        <result property="age" column="age"/>
    </resultMap>
     <select id="selectByName" resultMap="BaseColumn">
        select id,name,age from student where name LIKE '%'#{name}'%'
    </select>
</mapper>

上面的sql语句表示的意思是通过学生名称来模糊匹配学生

public interface StudentMapper {
    /**
     * @param name
     * @return
     */
    List<Student> selectByName(@Param("name") String name);
}

维护完映射文件和对应的接口之后，我们还需要一个XML配置文件来对MyBatis进行一些核心设置，包括获取数据库连接实例的数据源（DataSource）和决定事务作用域和控制方式的事务管理器（TransactionManager）以及SQL映射文件的位置信息等。本节所使用的配置如下：

<configuration>
    <!--加载配置文件->jdbc.properties 数据库文件 -->
    <properties resource="jdbc.properties"/>
    <!-- 设置一个默认的连接环境信息 -->
    <environments default="development">
        <!--连接环境信息，取一个任意唯一的名字 -->
        <environment id="development">
            <!-- mybatis使用jdbc事务管理方式 -->
            <transactionManager type="JDBC"/>
            <!-- mybatis使用连接池方式来获取连接 -->
            <dataSource type="POOLED">
                <!-- 配置与数据库交互的4个必要属性 -->
                <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>
        <mapper resource="xml/StudentMapper.xml"/>
    </mappers>
</configuration>

到此，MyBatis所需的环境就配置好了，接下来我们将MyBatis跑起来。测试代码如下

private SqlSessionFactory sqlSessionFactory;
    @Before
    public void setUp() {
        String resource = "chapter1/mybatis-cfg.xml";
        try {
            InputStream inputStream = Resources.getResourceAsStream(resource);
            sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream, "development");
            inputStream.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
    @Test
    public void mybatisTest() {
        SqlSession sqlSession = sqlSessionFactory.openSession();
        StudentMapper mapper = sqlSession.getMapper(StudentMapper.class);
        List<Student> studentList = mapper.selectByName("点点");
        if (studentList != null) {
            System.out.println("----->"+studentList.get(0).toString());
        }
        sqlSession.commit();
        sqlSession.close();
    }

如上测试代码，首先，我们根据配置文件得到文件流，然后通过SqlSessionFactoryBuilder工厂类构造器得到SqlSessionFactory，再通过SqlSessionFactory工厂类得到SqlSession。然后根据SqlSession的getMapper()方法得到需要执行的mapper。得到之后调用相应的方法得到结果。

运行结果如下：

f4bbc48ced080a63cda9de48f736d963_20190414200852579.png

使用JDBC访问数据库

现在我们使用原生的JDBC来操作数据库，主要流程有以下几个：1. 加载数据库驱动，2. 连接数据库，3，通过PreparedStatement执行sql得到ResultSet，4，对ResultSet 进行处理。流程固定。

public class JdbcTest {
    public static void main(String[] args) {
        String driver = "com.mysql.jdbc.Driver";
        String url = "jdbc:mysql://localhost:3306/mybatisdemo";
        String userName = "root";
        String password = "admin";
        Connection conn = null;
        PreparedStatement statement = null;
        ResultSet resultSet = null;
        try {
            Class.forName(driver);
            conn = DriverManager.getConnection(url, userName, password);
            String sql = "select id,name,age from student where name LIKE ?";
            statement = conn.prepareStatement(sql);
            statement.setString(1, "%点点%");
            resultSet = statement.executeQuery();
            List<Student> studentList = new ArrayList<Student>();
            if (resultSet != null) {
                while (resultSet.next()) {
                    Student student = new Student();
                    student.setId(resultSet.getInt("id"));
                    student.setName(resultSet.getString("name"));
                    student.setAge(resultSet.getInt("age"));
                    studentList.add(student);
                }
            }
      System.out.println("----->执行的sql={}"+sql);
            System.out.println("----->resultSet={}"+studentList.get(0).toString());
        } catch (Exception e) {
            e.printStackTrace();
        }finally {
            try {
                if (statement != null) {
                    statement.close();
                }
                if (conn != null) {
                    conn.close();
                }
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }
    }
}

代码比较简单，执行结果如下：

50399d26accce2662946ce93e3d1d323_20190414204627535.png

上面的代码的步骤比较多，但是核心步骤只有两步，分别是执行SQL和处理查询结果。从开发人员的角度来说，我们只关心这两个步骤。原生的JDBC的缺点主要有如下几点：

1.每次为了执行某个SQL需要写很多额外的代码，比如加载驱动，创建数据库连接，代码冗余。

2.将SQL写在代码中，如果要改动SQL，就需要到代码中进行修改，这样做不合适，因为改动了Java代码就需要重新编译Java文件，在打包发布，同时将SQL和Java代码混在一起，会降低代码的可读性，不利于维护。

3.关于执行结果的处理，需要手动的将数据从ResultSet中取出，并设置到我们需要的对象中，如果属性过多，用这种方式处理会非常繁琐。

4.每次都要手动管理数据库连接，使用好之后又要手动关闭。

MyBatis VS JDBC

首先我们来看看MyBatis访问数据库的过程

1.读取配置文件

2.创建SqlSessionFactoryBuilder对象

3.通过SqlSessionFactoryBuilder创建SqlSessionFactory对象

4.通过SqlSessionFactory创建SqlSession

为Dao 接口生成代理类

6.调用接口方法访问数据库

需要注意的是，在MyBatis中SqlSessionFactoryBuilder 和 SqlSessionFactory 以及 SqlSession 等对象的作用域和生命周期是不一样的。

SqlSessionFactoryBuilder

这个类可以被实例化，使用和丢弃，一旦创建了SqlSessionFactory，就不需要它了，所以，SqlSessionFactoryBuilder实例的最佳作用域是方法作用域（也就是局部方法变量）

SqlSessionFactory

SqlSessionFactory一旦被创建就应该在应用的运行期间一直存在，没有任何理由丢弃它或重新创建另外一个实例，使用SqlSessionFactory的最佳实践食杂应用运行期间不要重复创建多起，多次重建SqlSessionFactory被视为一种代码”坏味道“。因此SqlSessionFactory的最佳作用域是应用作用域，有很多方法可以做到，最简单的就是使用单例模式或者静态单例模式。

SqlSession

每个线程都应该有它自己的SqlSession实例，SqlSession的实例不是线程安全的，因此是不能被共享的，所有它的最佳的作用域是请求或方法作用域，绝对不能讲SqlSession实例的引用放在了一个类的静态域，比如Servlet框架中的HttpSession中。

映射器实例

映射器是一些由你创建的，绑定你映射的语句的接口，映射器接口的实例是从SqlSession中获得的，因此从技术层面讲，任何映射器实例的最大作用域是请求他们的的SqlSession相同的，尽管如此，映射器实例的最佳作用域是方法作用域。也就是说，映射器实例应该在调用它们的方法中被请求，用过之后即可丢弃。并不需要显示地关闭映射器实例。

总的来说，MyBatis在易用性上要比JDBC好太多，不过JDBC与MyBatis的目标不同，JDBC是作为一种基础服务，而MyBatis则是构建在基础服务之上的框架。所以JDBC的流程繁琐，从JDBC的角度来说，这里的每一个步骤对于完成数据访问请求来说都是必须的。

使用Spring JDBC访问数据库

Spring JDBC是在JDBC上面做的一层比较薄的封装，主要是为了解决直接使用JDBC的一些痛点，易用性得到了不少的提升。

引入的依赖

<properties>
        <spring.version>4.3.17.RELEASE</spring.version>
    </properties>
 <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-jdbc</artifactId>
            <version>${spring.version}</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-test</artifactId>
            <version>${spring.version}</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>${spring.version}</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-beans</artifactId>
            <version>${spring.version}</version>
        </dependency>

在使用Spring JDBC之前我们需要做一些配置，我们新建一个配置文件，命名为application.xml，在此配置文件中，我们配置了

数据库的连接信息dataSource，注册了JdbcTemplate实例。

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:context="http://www.springframework.org/schema/context"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd">
    <context:property-placeholder  location="jdbc.properties"/>
    <bean id="dataSource" class="org.apache.ibatis.datasource.pooled.PooledDataSource">
        <!-- 配置与数据库交互的4个必要属性 -->
        <property name="driver" value="${jdbc.driver}"/>
        <property name="url" value="${jdbc.url}"/>
        <property name="username" value="${jdbc.username}"/>
        <property name="password" value="${jdbc.password}"/>
    </bean>
    <bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">
        <property name="dataSource" ref="dataSource"/>
    </bean>
</beans>

配置完成之后，我们可以写一个测试类来测试一下。

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration("classpath:chapter1/application.xml")
public class SpringJdbcTest {
    @Autowired
    private JdbcTemplate jdbcTemplate;
    @Test
    public void  testSpringJdbc() {
        String sql = "select id,name,age from student where name LIKE ?";
        List<Student> studentList = jdbcTemplate.query(sql, new Object[]{"%点点%"}, new BeanPropertyRowMapper<Student>(Student.class));
        System.out.println("----->执行的sql={}"+sql);
        System.out.println("----->查询结果={}"+studentList.get(0).toString());
    }
}

运行结果

dafe0a5628e3d8644787f956feb33fe0_20190414230532617.png

从上面的测试代码我们可以看出，相对于原生JDBC，Spring JDBC 易用性大大提升，注入jdbcTemplate之后，我们就可以通过jdbcTemplate来操作，只关注sql的执行以及结果的处理即可。代码简化了很多。但是SQL语句仍然写在代码中。


使用Hibernate 访问数据库

本节会像之前的章节一样，我会先写代码进行演示，然后在对比Hibernate 和MyBatis的区别。

Hibernate 访问数据库的过程演示

首先，在POM文件中添加所需依赖

<dependency>
            <groupId>org.hibernate</groupId>
            <artifactId>hibernate-core</artifactId>
            <version>5.3.2.Final</version>
        </dependency>

接着进行环境配置，主要是关于数据库方面的配置。

<hibernate-configuration>
    <session-factory>
        <property name="hibernate.connection.driver_class">com.mysql.jdbc.Driver</property>
        <property name="hibernate.connection.url">jdbc:mysql://localhost:3306/mybatisdemo</property>
        <property name="hibernate.connection.username">root</property>
        <property name="hibernate.connection.password">admin</property>
        <property name="hibernate.dialect">org.hibernate.dialect.MySQL5Dialect</property>
        <property name="hibernate.show_sql">true</property>
        <mapping resource="chapter1/xml/Student.hbm.xml" />
    </session-factory>
</hibernate-configuration>

环境配置完成之后，我们接着编写映射文件，将表字段与实体类的属性关联起来。如下Student.hbm.xml

<hibernate-mapping package="com.jay.entity">
    <class table="student" name="Student">
        <id name="id" column="id">
            <generator class="native"/>
        </id>
        <property name="name" column="name"/>
        <property name="age" column="age"/>
        <property name="classId" column="class_id"/>
    </class>
</hibernate-mapping>

所有配置完成之后，我们就可以开始编写测试代码进行测试：

public class HibernateTest {
    private SessionFactory sessionFactory;
    @Before
    public void init() {
        Configuration configuration = new Configuration();
        configuration.configure("chapter1/hibernate.cfg.xml");
        sessionFactory = configuration.buildSessionFactory();
    }
    @After
    public void destroy() {
        sessionFactory.close();
    }
    @Test
    public void testORM() {
        System.out.println("--------------ORM Query-------------");
        Session session = null;
        try {
            session = sessionFactory.openSession();
            int id = 1;
            Student student = session.get(Student.class, id);
            System.out.println("ORM Query Result:");
            System.out.println(student.toString());
            System.out.println();
        } finally {
            if (Objects.nonNull(session)) {
                session.close();
            }
        }
    }
    @Test
    public void testHQL() {
        System.out.println("--------------HQL Query-----------");
        Session session = null;
        try {
            session = sessionFactory.openSession();
            String hql = "FROM Student WHERE name=:name";
            Query query = session.createQuery(hql);
            query.setParameter("name", "点点");
            List<Student> studentList = query.list();
            System.out.println("HQL Query Result:");
            studentList.forEach(System.out::println);
            System.out.println();
        } finally {
            if (Objects.nonNull(session)) {
                session.close();
            }
        }
    }
   @Test
    public void testJpaCriteria() {
       System.out.println("-------------JPA Criteria-------------");
       Session session = null;
       try {
           session = sessionFactory.openSession();
           CriteriaBuilder criteriaBuilder = session.getCriteriaBuilder();
           CriteriaQuery<Student> criteriaQuery = criteriaBuilder.createQuery(Student.class);
//       定义FROM子句
           Root<Student> student = criteriaQuery.from(Student.class);
//       构建查询条件
           Predicate equal = criteriaBuilder.equal(student.get("name"), "点点");
//       通过具有语义化的方法构建SQL，等价于SELECT ... FROM student WHERE ...
           criteriaQuery.select(student).where(equal);
           Query<Student> query = session.createQuery(criteriaQuery);
           List<Student> studentList = query.getResultList();
           System.out.println("JPA Criteria Query Result:");
           studentList.forEach(System.out::println);
       } finally {
           if (Objects.nonNull(session)) {
               session.close();
           }
       }
   }
}

如上代码清单所示，我编写了三个测试用例，第一个直接使用Hibernate生成SQL的功能，如果查询比较简单可以采用此种方式，生成的SQL是

select student0_.id as id1_0_0_, student0_.name as name2_0_0_, student0_.age as age3_0_0_, student0_.class_id as class_id4_0_0_ from student student0_ where student0_.id=?

第二个测试用例，我编写了一条HQL语句，并通过Query来设置参数，同样Hibernate在运行时会将HQL转化成对应的SQL,转化后的SQL如下：

select student0_.id as id1_0_, student0_.name as name2_0_, student0_.age as age3_0_, student0_.class_id as class_id4_0_ from student student0_ where student0_.name=?

第三个测试用例，我们使用JPA Criteria 进行查询，JPA Criteria 具有类型安全，面向对象和语义化的特点，使用JPA Criteria，我们可以用写Java 代码的方式进行数据库操作，无需手写SQL,第三个用例和第二个用例进行的是同样的查询，所以生成的SQL区别不大。

测试代码的运行结果：

02430f871bcb924de3b912d2db0447ea_watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3UwMTQ1MzQ4MDg=,size_16,color_FFFFFF,t_70.png

MyBatis VS Hibernate

至此，我们已经对MyBatis和Hibernate访问数据库的过程都做了一次演示，下面我们来对比下MyBatis和Hibernate

MyBatis 需要使用者自行维护SQL，灵活性高，方便对sql进行优化，Hibernate 可以自动生成SQL，使用成本小。

MyBatis 适合于需求变动频繁，业务量的系统，Hibernate 更加适合于变动比较小的系统，比如OA系统

使用Spring Data JPA 访问数据库

首先引入依赖

<properties>
        <spring.version>4.3.17.RELEASE</spring.version>
    </properties>
 <!--///Spring JPA-->
        <dependency>
            <groupId>org.springframework.data</groupId>
            <artifactId>spring-data-jpa</artifactId>
            <version>1.11.8.RELEASE</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-core</artifactId>
            <version>${spring.version}</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-aop</artifactId>
            <version>${spring.version}</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-tx</artifactId>
            <version>${spring.version}</version>
        </dependency>
        <dependency>
            <groupId>org.aspectj</groupId>
            <artifactId>aspectjrt</artifactId>
            <version>1.6.12</version>
        </dependency>
        <dependency>
            <groupId>org.aspectj</groupId>
            <artifactId>aspectjweaver</artifactId>
            <version>1.6.12</version>
        </dependency>

接着添加配置文件application-jpa.xml，主要是配置数据库连接信息，以及事务相关的信息

<!--启用注解配置和包扫描-->
    <context:annotation-config/>
    <context:component-scan base-package="com.jay"/>
    <!--创建Spring Data JPA实例对象-->
    <jpa:repositories base-package="com.jay.chapter1"/>
    <context:property-placeholder  location="jdbc.properties"/>
    <bean id="dataSource"
          class="org.apache.ibatis.datasource.pooled.PooledDataSource">
        <!-- 配置与数据库交互的4个必要属性 -->
        <property name="driver" value="${jdbc.driver}"/>
        <property name="url" value="${jdbc.url}"/>
        <property name="username" value="${jdbc.username}"/>
        <property name="password" value="${jdbc.password}"/>
    </bean>
    <bean id="entityManagerFactory"
          class="org.springframework.orm.jpa.LocalContainerEntityManagerFactoryBean">
        <property name="dataSource" ref="dataSource"/>
        <property name="packagesToScan" value="com.jay.entity"/>
        <property name="jpaVendorAdapter">
            <bean class="org.springframework.orm.jpa.vendor.HibernateJpaVendorAdapter">
                <property name="generateDdl" value="true"/>
                <property name="showSql" value="true"/>
            </bean>
        </property>
    </bean>
    <!--事务管理器-->
    <bean id="transactionManager"
          class="org.springframework.orm.jpa.JpaTransactionManager">
        <property name="entityManagerFactory" ref="entityManagerFactory"/>
    </bean>
    <!--事务管理-->
    <tx:advice id="transactionAdvice"
               transaction-manager="transactionManager">
        <tx:attributes>
            <tx:method name="get*" read-only="true"/>
            <tx:method name="*"/>
        </tx:attributes>
    </tx:advice>
    <aop:config>
        <aop:pointcut id="daoPointCut" expression="execution(* com.jay.chapter1.mapper.*.*(..))"/>
        <aop:advisor advice-ref="transactionAdvice" pointcut-ref="daoPointCut"/>
    </aop:config>

配置文件添加完成之后，接着我们编写一个接口继承CrudRepository接口，使其具备基本的增删改查功能。

public interface JpaStudentDao extends CrudRepository<JpaStudent,Integer>{
    /**
     * @param name
     * @return
     */
    List<JpaStudent> getByNameLike(String name);
}

DAO接口添加完成之后，接着我们添加一个测试类进行测试。

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration("classpath:chapter1/application-jpa.xml")
public class JPATest {
    @Autowired
    JpaStudentDao jpaStudentDao;
    @Before
   public void init() {
        JpaStudent jpaStudent = new JpaStudent("张三", 12, "121");
        jpaStudentDao.save(jpaStudent);
    }
    @Test
    public void testCrudRepostitory() {
        List<JpaStudent> jpaStudents = jpaStudentDao.getByNameLike("张三");
        jpaStudents.forEach(System.out::println);
        System.out.println();
    }
}

如上测试类所示，我先使用了JPA自带的save方法向数据库中插入了一条数据，接着自定义了一个查询方法。JPA中查询方法可以由我们声明的命名查询生成，也可以由方法名解析

方法名以find…By, read…By, query…By, count…By和 get…By做开头。在By之前可以添加Distinct表示查找不重复数据。By之后是真正的查询条件。

可以查询某个属性，也可以使用条件进行比较复杂的查询，例如Between, LessThan, GreaterThan, Like，And,Or等。

字符串属性后面可以跟IgnoreCase表示不区分大小写，也可以后跟AllIgnoreCase表示所有属性都不区分大小写。

可以使用OrderBy对结果进行升序或降序排序。

可以查询属性的属性，直接将几个属性连着写即可，如果可能出现歧义属性，可以使用下划线分隔多个属性。

运行结果如下：

5a216fe8e29925208b2a58bab1fd453b_20190415230434228.png

MyBatis VS JPA

通过上面的实例，我们可以了解到JPA的使用，JPA类似于Hibernate都可以自动生成SQL,不同之处是，JPA还可以根据方法名来解析生成sql。MyBatis 还是需要使用者自行维护sql。

总结

本篇文章对MyBatis 是什么，为什么使用，以及与其他ORM框架进行了对比。

参考文献

MyBatis官方文档

MyBatis 源码分析系列文章导读

《MyBatis 技术内幕》- 徐郡明

Spring Data JPA 介绍和使用

源代码

https://github.com/XWxiaowei/MyBatisLearn/tree/master/mybatisDemo

文章标签：
云数据库 RDS MySQL 版
Java
测试技术
SQL
Apache
Spring
mybatis
数据格式
数据库
XML
数据库连接
关键词：
MyBatis框架
MyBatis简介
MyBatis orm
MyBatis学习笔记
MyBatis学习笔记框架
相关实践学习
每个IT人都想学的“Web应用上云经典架构”实战
本实验从Web应用上云这个最基本的、最普遍的需求出发，帮助IT从业者们通过“阿里云Web应用上云解决方案”，了解一个企业级Web应用上云的常见架构，了解如何构建一个高可用、可扩展的企业级应用架构。
MySQL数据库入门学习
本课程通过最流行的开源数据库MySQL带你了解数据库的世界。 &nbsp; 相关的阿里云产品：云数据库RDS MySQL 版 阿里云关系型数据库RDS（Relational Database Service）是一种稳定可靠、可弹性伸缩的在线数据库服务，提供容灾、备份、恢复、迁移等方面的全套解决方案，彻底解决数据库运维的烦恼。 了解产品详情:&nbsp;https://www.aliyun.com/product/rds/mysql&nbsp;
码农飞哥
目录
相关文章
SQL XML Java
32 0
蓝易云
|
27天前
|
SQL Java 数据库连接
区分iBatis与MyBatis：两个Java数据库框架的比较
总结起来：虽然从技术角度看,iBATIS已经停止更新但仍然可用；然而考虑到长期项目健康度及未来可能需求变化情况下MYBATISS无疑会是一个更佳选择因其具备良好生命周期管理机制同时也因为社区力量背书确保问题修复新特征添加速度快捷有效.
蓝易云
69 12
蓝易云
|
2月前
|
SQL XML Java
MyBatis框架如何处理字符串相等的判断条件。
总的来说，MyBatis框架提供了灵活而强大的机制来处理SQL语句中的字符串相等判断条件。无论是简单的等值判断，还是复杂的条件逻辑，MyBatis都能通过其标签和属性来实现，使得动态SQL的编写既安全又高效。
蓝易云
149 0
游客kufrkwrbkmpsa
|
7月前
|
Oracle 关系型数据库 Java
【YashanDB数据库】Mybatis-plus分页框架识别不到Yashandb
Mybatis-plus分页框架识别不到Yashandb
游客kufrkwrbkmpsa
122 0
拉丁解牛说技术
|
7月前
|
SQL 缓存 Java
框架源码私享笔记(02)Mybatis核心框架原理 | 一条SQL透析核心组件功能特性
本文详细解构了MyBatis的工作机制，包括解析配置、创建连接、执行SQL、结果封装和关闭连接等步骤。文章还介绍了MyBatis的五大核心功能特性：支持动态SQL、缓存机制（一级和二级缓存）、插件扩展、延迟加载和SQL注解，帮助读者深入了解其高效灵活的设计理念。
拉丁解牛说技术
207 1
刘大猫.
|
7月前
|
SQL XML Java
一、MyBatis简介：MyBatis历史、MyBatis特性、和其它持久化层技术对比、Mybatis下载依赖包流程
一、MyBatis简介：MyBatis历史、MyBatis特性、和其它持久化层技术对比、Mybatis下载依赖包流程
刘大猫.
259 69
蓝易云
|
9月前
|
SQL Java 数据库连接
对Spring、SpringMVC、MyBatis框架的介绍与解释
Spring 框架提供了全面的基础设施支持，Spring MVC 专注于 Web 层的开发，而 MyBatis 则是一个高效的持久层框架。这三个框架结合使用，可以显著提升 Java 企业级应用的开发效率和质量。通过理解它们的核心特性和使用方法，开发者可以更好地构建和维护复杂的应用程序。
蓝易云
381 29
gkkkkk
|
11月前
|
SQL Java 数据库连接
持久层框架MyBatisPlus
持久层框架MyBatisPlus
gkkkkk
213 1
持久层框架MyBatisPlus
2G冲浪词条
|
4月前
|
Java 数据库连接 数据库
Spring boot 使用mybatis generator 自动生成代码插件
本文介绍了在Spring Boot项目中使用MyBatis Generator插件自动生成代码的详细步骤。首先创建一个新的Spring Boot项目，接着引入MyBatis Generator插件并配置`pom.xml`文件。然后删除默认的`application.properties`文件，创建`application.yml`进行相关配置，如设置Mapper路径和实体类包名。重点在于配置`generatorConfig.xml`文件，包括数据库驱动、连接信息、生成模型、映射文件及DAO的包名和位置。最后通过IDE配置运行插件生成代码，并在主类添加`@MapperScan`注解完成整合
2G冲浪词条
620 1
Spring boot 使用mybatis generator 自动生成代码插件
Quan_Chen
|
7月前
|
XML Java 数据库连接
微服务——SpringBoot使用归纳——Spring Boot集成MyBatis——基于注解的整合
本文介绍了Spring Boot集成MyBatis的两种方式：基于XML和注解的形式。重点讲解了注解方式，包括@Select、@Insert、@Update、@Delete等常用注解的使用方法，以及多参数时@Param注解的应用。同时，针对字段映射不一致的问题，提供了@Results和@ResultMap的解决方案。文章还提到实际项目中常结合XML与注解的优点，灵活使用两者以提高开发效率，并附带课程源码供下载学习。
Quan_Chen
547 0