Mybatis初步

最新推荐文章于 2021-01-30 17:57:16 发布
最新推荐文章于 2021-01-30 17:57:16 发布
阅读量347 收藏
点赞数 1
文章标签： mybatis 持久层框架
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/gorunbu/article/details/78130043
版权

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

1.准备开发环境

1、创建测试项目，普通java项目或者是JavaWeb项目均可，如下图所示：
这里写图片描述
添加相应的jar包：
mybatis-3.4.4.jar
mysql-connector-java-5.1.30-bin.jar
jsbc.prop[mysql数据库信息配置文件]：

#dbConfig
#Mon Jul 31 07:54:49 CST 2017
url=jdbc:mysql://localhost:3306/t_market
password=root
driver=com.mysql.jdbc.Driver
username=root

mybatis-config.xml[mybatis配资信息文件]:

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE configuration
    PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
    "http://mybatis.org/dtd/mybatis-3-config.dtd">

<configuration>

  <!-- properties属性,properties和java的.properties的配置文件有关;
  配置properties的resource指定.properties的路径;
  然后再在properties标签下配置property的name和value，
  则可以替换.properties文件中相应属性值。 -->
  <properties resource="jsbc.prop" />

  <!--typeAliases 必须在properties之后声明 -->
  <!-- typeAliases类型别名,类型别名是Java 类型的简称;它仅仅只是关联到XML 配置，简写冗长的JAVA 类名; -->
  <typeAliases>
    <!-- 定义别名User为javaBean类com.my.market.model.User -->
    <typeAlias alias="User" type="com.my.market.model.User"/>
  </typeAliases>

<!-- environments环境,MyBatis 可以配置多个环境。这可以帮助你SQL 映射对应多种数据库等; -->
  <environments default="development">
    <!-- 默认开发环境 -->
    <environment id="development">
      <!-- 事务管理器 -->
      <transactionManager type="JDBC"/>
      <!-- 数据源 -->
      <dataSource type="POOLED">
        <property name="driver" value="${driver}"/>
        <property name="url" value="${url}"/>
        <property name="username" value="${username}"/>
        <property name="password" value="${password}"/>
      </dataSource>
    </environment>
  </environments>

  <!-- 将model中类对应的mapper文件加入配置中-->
  <!-- mappers映射器,这里是告诉MyBatis 去哪寻找映射SQL 的语句;可以使用类路径中的资源引用，或者使用字符，输入确切的URL引用; -->
  <mappers>
    <mapper resource="com/my/market/model/User.xml"/>
  </mappers>

</configuration>

2.定义表所对应的实体类，如下图所示：

这里写图片描述
User.java[实体类User]:

package com.my.market.model;

public class User {
    private int id;
    private String username;
    private String password;
    private String nickname;
    private int type;
    public String getPassword() {
        return password;
    }
    public void setPassword(String password) {
        this.password = password;
    }
    public String getNickname() {
        return nickname;
    }
    public void setNickname(String nickname) {
        this.nickname = nickname;
    }
    public int getType() {
        return type;
    }
    public void setType(int type) {
        this.type = type;
    }
    public int getId() {
        return id;
    }
    public String getUsername() {
        return username;
    }
    public User(int id, String username, String password, String nickname, int type) {
        this.id = id;
        this.username = username;
        this.password = password;
        this.nickname = nickname;
        this.type = type;
    }
    public User() {
    }
    @Override
    public String toString() {
        return "User [id=" + id + ", username=" + username + ", password=" + password + ", nickname=" + nickname
                + ", type=" + type + "]";
    }
}

User.xml[User类对应的Mapper文件]:

<?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">

<!-- com.my.market.model.User实体类对应的mapper文件，namespace限定名字空间避免重复 -->
<mapper namespace="com.my.market.model.User">
    <!-- 通过[namespace.id 即 com.my.market.model.User.add]进行add的插入方法的调用 -->
    <insert id="add" parameterType="User">
        insert into t_user(username, password, nickname, type) 
        values(#{username},#{password},#{nickname},#{type})
    </insert>
    <update id="update" parameterType="User">
        update t_user set password=#{password},nickname=#{nickname},type=#{type} where id=#{id}
    </update>
    <delete id="delete" parameterType="int">
        delete from t_user where id=#{id}
    </delete>
    <select id="select" parameterType="int" resultType="User">
        select * from t_user where id=#{id}
    </select>
    <!-- 使用User别名 -->
    <select id="list" resultType="User">
        select * from t_user
    </select>
</mapper>

3.Junit测试类

MyBatisUtil.java[Mybatis工具类用来获取session]:

package com.my.market.util;

import java.io.Closeable;
import java.io.IOException;
import java.io.InputStream;

import org.apache.ibatis.io.Resources;
import org.apache.ibatis.session.SqlSession;
import org.apache.ibatis.session.SqlSessionFactory;
import org.apache.ibatis.session.SqlSessionFactoryBuilder;

public class MyBatisUtil {
    private static final String RESOURCE = "mybatis-config.xml";
    private static SqlSessionFactory factory;
    static {
        try {
            //1.创建配置文件(mybatis-config.xml)的输入流
            InputStream iStream=Resources.getResourceAsStream(RESOURCE);
            //2.创建SqlSessionFactory
            factory=new SqlSessionFactoryBuilder().build(iStream);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
    private MyBatisUtil() {
    }
    public static SqlSession getSession() {
        //3.创建SqlSession
        return factory.openSession();
    }
    public static void close(SqlSession session) {
        if(null!=session) {
            session.close();
        }
    }
}

TestMyBatisJunit.java[MyBatis Junit测试类]:

package com.my.market.test;

import static org.junit.Assert.*;

import java.io.IOException;
import java.io.InputStream;
import java.util.List;

import javax.jws.soap.SOAPBinding.Use;

import org.apache.ibatis.io.Resources;
import org.apache.ibatis.session.SqlSession;
import org.apache.ibatis.session.SqlSessionFactory;
import org.apache.ibatis.session.SqlSessionFactoryBuilder;
import org.junit.Test;

import com.my.market.model.User;
import com.my.market.util.MyBatisUtil;

public class TestMyBatisJunit {
    private static final String RESOURCE = "mybatis-config.xml";

    @Test
    public void testDelete() {
        InputStream is=null;
        try {
            is = Resources.getResourceAsStream(RESOURCE);
        } catch (IOException e) {
            e.printStackTrace();
        }
        SqlSessionFactory factory=new SqlSessionFactoryBuilder().build(is);
        SqlSession session=factory.openSession();
        System.out.println(User.class.getName());
        session.delete(User.class.getName()+".delete", 9);
        session.commit();
        session.close();
    }

    @Test
    public void testLoad() {
        SqlSession session=null;
        try {
            session=MyBatisUtil.getSession();
            User user=(User)session.selectOne(User.class.getName()+".select", 1);
            System.out.println(user);
        }finally {
            MyBatisUtil.close(session);
        }
    }
    @Test
    public void testAdd() {
        SqlSession session=null;
        try {
            session=MyBatisUtil.getSession();
            User user=new User(0, "tangseng1", "123", "唐僧1", 0);
            session.insert(User.class.getName()+".add", user);
            session.commit();
        }catch(Exception e) {
            session.rollback();
            e.printStackTrace();
        }
        finally {
            session.close();
        }
    }
    @Test
    public void testList() {
        SqlSession session=null;
        try {
            session=MyBatisUtil.getSession();
            List<User> userList=session.selectList(User.class.getName()+".list");
            for(User u: userList) {
                System.out.println(u);
            }
        }finally {
            MyBatisUtil.close(session);
        }
    }
}

4.工具，基础类

1.BaseDao.java[所有dao的基本父类]:

package com.my.market.dao;

import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.util.Arrays;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

import org.apache.ibatis.session.SqlSession;

import com.my.market.model.Address;
import com.my.market.model.Page;
import com.my.market.model.SystemContext;
import com.my.market.model.User;
import com.my.market.util.DBUtil;
import com.my.market.util.DaoUtil;
import com.my.market.util.LogUtil;
import com.my.market.util.MyBatisUtil;

public class BaseDao<T> {
    public BaseDao() {
//      //依赖注入,对于子类需要set的对象,例如setUserDao
//      Method[] methods=this.getClass().getDeclaredMethods();
//      //error:unknow function
//      //this.setUserDao(null);
//      System.out.println(Arrays.toString(methods));
//      for(Method m: methods) {
//          String methodName =m.getName();
//          if(methodName.startsWith("set")) {
//              LogUtil.printLog(m);
//              String name=methodName.substring(3);
//              LogUtil.printLog(methodName+":  "+name);
//              Object obj=DaoUtil.createDaoFactory().getDao(name);
//              try {
//                  m.invoke(this, obj);
//              } catch (IllegalAccessException | IllegalArgumentException | InvocationTargetException e) {
//                  e.printStackTrace();
//              }
//          }
//      }
        DaoUtil.diDao(this);
    }
    public void add(T obj) {
        SqlSession session=null;
        try {
            session=MyBatisUtil.getSession();
            session.insert(obj.getClass().getName()+".add", obj);
            session.commit();
        }catch(Exception e) {
            session.rollback();
            e.printStackTrace();
        }finally {
            MyBatisUtil.close(session);
        }
    }
    public <Type> void add(String sqlId, Type obj) {
        SqlSession session=null;
        try {
            session=MyBatisUtil.getSession();
            session.insert(sqlId, obj);
            session.commit();
        }catch(Exception e) {
            session.rollback();
            e.printStackTrace();
        }finally {
            MyBatisUtil.close(session);
        }
    }
    public void update(T obj) {
        SqlSession session=null;
        try {
            session=MyBatisUtil.getSession();
            session.update(obj.getClass().getName()+".update", obj);
            session.commit();
        }catch(Exception e) {
            session.rollback();
            e.printStackTrace();
        }finally {
            MyBatisUtil.close(session);
        }
    }
    public void delete(Class<T> clz, int id) {
        SqlSession session=null;
        try {
            session=MyBatisUtil.getSession();
            session.delete(clz.getName()+".delete", id);
            session.commit();
        }catch(Exception e){
            session.rollback();
            e.printStackTrace();
        }finally {
            MyBatisUtil.close(session);
        }
    }
    public void delete(String sqlId, Map<String, Object> params) {
        SqlSession session=null;
        try {
            session=MyBatisUtil.getSession();
            session.delete(sqlId, params);
            session.commit();
        }catch(Exception e){
            session.rollback();
            e.printStackTrace();
        }finally {
            MyBatisUtil.close(session);
        }
    }
    public T load(Class<T> clz, int id) {
        SqlSession session=null;
        T obj=null;
        try {
            session=MyBatisUtil.getSession();
            obj= session.selectOne(clz.getName()+".load", id);
        }finally {
            MyBatisUtil.close(session);
        }
        return obj;
    }
    public T loadBySqlId(String sqlId, Map<String, Object> params) {
        SqlSession session=null;
        T obj=null;
        try {
            session=MyBatisUtil.getSession();
            obj= session.selectOne(sqlId, params);
        }finally {
            MyBatisUtil.close(session);
        }
        return obj;
    }
    public T loadBySqlId(String sqlId, Object param) {
        SqlSession session=null;
        T obj=null;
        try {
            session=MyBatisUtil.getSession();
            obj= session.selectOne(sqlId, param);
        }finally {
            MyBatisUtil.close(session);
        }
        return obj;
    }
    public Page<T> find(Class<T> clz, Map<String, Object> params){
        int pageSize =SystemContext.getMaxPageItems();
        int pagerOffset=SystemContext.getPagerOffset();
        String order=SystemContext.getOrder();
        String condition=SystemContext.getCondition();
        Page<T> page = null;
        SqlSession session=null;
        try {
            session=MyBatisUtil.getSession();
            if(null==params) {
                params=new HashMap<>();
            }
            params.put("pageSize", pageSize);
            params.put("pagerOffset", pagerOffset);
            params.put("order", order);
            params.put("condition", condition);
            List<T> objList=session.selectList(clz.getName()+".find", params);
            int totalRecord=session.selectOne(clz.getName()+".find_count", params);
            page=new Page<T>(pagerOffset/pageSize+1, totalRecord, pageSize,
                    totalRecord/pageSize+(totalRecord%pageSize==0? 0:1), objList);
        }finally {
            MyBatisUtil.close(session);
        }
        return page;
    }
    public Page<T> find(String sqlId, Map<String, Object> params){
        int pageSize =SystemContext.getMaxPageItems();
        int pagerOffset=SystemContext.getPagerOffset();
        String order=SystemContext.getOrder();
        String condition=SystemContext.getCondition();
        Page<T> page = null;
        SqlSession session=null;
        try {
            session=MyBatisUtil.getSession();
            if(null==params) {
                params=new HashMap<>();
            }
            params.put("pageSize", pageSize);
            params.put("pagerOffset", pagerOffset);
            params.put("order", order);
            params.put("condition", condition);
            List<T> objList=session.selectList(sqlId, params);
            LogUtil.printLog(sqlId);
            LogUtil.printLog(sqlId+"_count");
            int totalRecord=session.selectOne(sqlId+"_count", params);
            page=new Page<T>(pagerOffset/pageSize+1, totalRecord, pageSize,
                    totalRecord/pageSize+(totalRecord%pageSize==0? 0:1), objList);
        }finally {
            MyBatisUtil.close(session);
        }
        return page;
    }
    public List<T> listBySqlId(String sqlId, Map<String, Object> params){
        List<T> objList= null;
        SqlSession session=null;
        try {
            session=MyBatisUtil.getSession();
            if(null==params) {
                params=new HashMap<>();
            }
            objList=session.selectList(sqlId, params);
        }finally {
            MyBatisUtil.close(session);
        }
        return objList;
    }
}

2.DaoUtil.java[工厂模式的获取，依赖注入]:

package com.my.market.util;

import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.util.Properties;

import com.my.market.dao.IFactoryDao;
import com.my.market.model.MarketDi;

public class DaoUtil {
    public static void main(String[] args) {
        createDaoFactory();
    }
    public static IFactoryDao createDaoFactory() {
        Properties properties= PropertiesUtil.getDaoProp();
        String factoryName=properties.getProperty("factory");
        LogUtil.printLog(factoryName);
        IFactoryDao daoFactory=null;
        try {
            Class<?> clz=Class.forName(factoryName);
            String methodName="getInstance";
            Method method=clz.getMethod(methodName);
            daoFactory =(IFactoryDao)method.invoke(clz);
        } catch (ClassNotFoundException | NoSuchMethodException | SecurityException | IllegalAccessException |
                IllegalArgumentException | InvocationTargetException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        LogUtil.printLog(daoFactory);
        return daoFactory;
    }

    public static void diDao(Object obj) {
        //get the class from the object which will set value into it
        Class<?> clz=obj.getClass();
        //get declared methods from the class
        Method[] methods=clz.getDeclaredMethods();
        for(Method m: methods) {
            //if the Method has 'MarketDi' annotation, it show the Method want to get a object
            if(m.isAnnotationPresent(MarketDi.class)) {
                MarketDi aDi=m.getAnnotation(MarketDi.class);
                String objName=aDi.value();
                if(null==objName || "".equals(objName)) {
                    String methodName=m.getName();
                    LogUtil.printLog(methodName+": "+objName);
                    if(methodName.startsWith("set")) {
                        LogUtil.printLog(m);
                        objName=methodName.substring(3);
                    }
                }
                //get className from properties file, invoke the Method, set the object into it
                try {
                    Properties properties=PropertiesUtil.getDaoProp();
                    String className=properties.getProperty(objName);
                    LogUtil.printLog(objName+": "+className);
                    Object object=Class.forName(className).newInstance();
                    m.invoke(obj, object);
                } catch (InstantiationException | IllegalAccessException | ClassNotFoundException |
                        IllegalArgumentException | InvocationTargetException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

3.PropertiesUtil.java[属性读取工具]:

package com.my.market.util;

import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.Properties;

import sun.security.jca.GetInstance;

public class PropertiesUtil {
    private static Properties dBProperties=null;
    private static Properties daoProperties=null;
    private static final String CONFIG_FILE="dbConfi.prop";
    private static final String DAO_FILE="dao.prop";
    private PropertiesUtil() {
    }
    public static Properties getInstance() {
        if(null==dBProperties) {
            synchronized (PropertiesUtil.class) {
                if(null==dBProperties) {
                    dBProperties=new Properties();
//                  try(
//                      FileInputStream fin=new FileInputStream("/"+CONFIG_FILE);
//                  ){
                    try{
                        File f1=new File("test.txt");
                        LogUtil.printLog(f1.getAbsolutePath());
                        LogUtil.printLog(PropertiesUtil.class.getResource(CONFIG_FILE));
                        dBProperties.load(PropertiesUtil.class.getResourceAsStream(CONFIG_FILE));
                    }catch (Exception e) {
                        e.printStackTrace();
                        System.exit(-1);
                    }
                }
            }
        }
        return dBProperties;
    }
    public static Properties getDaoProp() {
        try {
            if(null==daoProperties) {
                synchronized(PropertiesUtil.class) {
                    if(null==daoProperties) {
                        daoProperties=new Properties();
                        daoProperties.load(PropertiesUtil.class.getClassLoader().getResourceAsStream(DAO_FILE));
                    }
                }
            }
        }catch(IOException e) {
            e.printStackTrace();
        }
        return daoProperties;
    }
}

DaoFactoryByProperties.java[通过properties获取Dao工厂]:

package com.my.market.dao;

import java.util.HashMap;
import java.util.Map;
import java.util.Properties;

import com.my.market.util.LogUtil;
import com.my.market.util.PropertiesUtil;

public class DaoFactoryByProperties implements IFactoryDao {
    private static DaoFactoryByProperties factory=new DaoFactoryByProperties();
    private static Map<String, Object> daoMap=new HashMap<>();
    private DaoFactoryByProperties() {
    }
    public static IFactoryDao getInstance() {
        return factory;
    }
    @Override
    public Object getDao(String name) {
        Object object=null;
        Properties properties=PropertiesUtil.getDaoProp();
        String daoClassName=properties.getProperty(name);
        LogUtil.printLog(daoClassName);
        if(daoMap.containsKey(daoClassName)) {
            return daoMap.get(daoClassName);
        }
        try {
            object=Class.forName(daoClassName).newInstance();
            daoMap.put(daoClassName, object);
        } catch (InstantiationException | IllegalAccessException | ClassNotFoundException e) {
            e.printStackTrace();
        }
        return object;
    }

}

5.mybatis使用步骤

操作步骤
1、将jar导入到项目
2、创建Config.xml文件用来指定相应的数据库连接信息
这里写图片描述
这里写图片描述
3、创建mapp.xml文件
这里写图片描述
4、创建SqlSessionFactory
这里写图片描述
5、根据factory获取session
这里写图片描述
6、直接根据session来执行相应的操作
这里写图片描述

6.map文件中的insert,update,delete,select

insert标签表示添加相应的对象信息,paramterType表示添加的对象类型
这里写图片描述
update表示更新操作，delete表示删除操作
这里写图片描述
select表示查询操作，可以查询列表或者单个对象
这里写图片描述
相应的调用方式
这里写图片描述

7.mapp.xml中两种引用

1、#{xxx}这种方式会自动将这个值替换为PreparedStatment中?来使用，如果是字符串会自动加上引号，对于排序而言就无法操作
2、${xx}这种方式叫做完全替换，直接将字符串完整的替换到这个位置，完全替换的方式可能会出现SQL注入的安全隐患。建议在参数中不要使用这种方式。但是如果使用在排序中没有任何影响
这里写图片描述

8.动态SQL语句

在mapp.xml文件中可能会根据一些参数值的不同而动态的产生相应的SQL语句，此时就需要进行动态SQL语句的设定
这里写图片描述

9.Resultmap的使用

使用ResultMap可以完成相应的结果集自定义输出
这里写图片描述
ResultMap还可以完成一些外键对对象的映射
这里写图片描述
使用以上映射方式有一个致命的缺点：所谓的N+1问题
使用关联查询来解决N+1问题
这里写图片描述

gorunbu
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
mybatis 初步使用
11-13
MyBatis 是一款深受开发者喜爱的持久层框架，它提供了灵活的 SQL 执行和映射功能，有效地将 Java 代码与数据库操作分离，使得开发更加高效。MyBatis 消除了几乎所有的 JDBC 代码和手动设置参数以及获取结果集的工作...
mybatis初步环境搭建
09-04
### MyBatis初步环境搭建详解 #### 一、MyBatis概述 MyBatis是一个半自动的ORM（Object Relational Mapping）框架，在当前的企业级应用开发中占据着重要的位置。ORM框架的主要目的是为了简化Java应用程序与数据库...
MyBatis初步
muran202236的博客
11-05 102
mybatis使用依赖 <dependency> <groupId>org.mybatis</groupId> <artifactId>mybatis-spring</artifactId> <version>1.3.1</version> </dependency> <!--mysql驱动--> <dependency>
Mybatis初步入门
qtds114的博客
01-30 176
文章目录Mybatis初步入门1 简介1.1 获得Mybatis1.2 持久层概念1.3 持久层1.4为什么要Mybatis？2 第一个mybatis程序2.1 搭建环境2.2 编写配置文件**2.3 编写mybatis工具类**2.4 编写mapper接口类与对应配置文件3 测试及常见异常3.1 编写测试类3.2 测试常见异常3.3 测试结果4 结语 这篇文章前面基本上都是看的b站狂神的mybatis写的，后面的话就是我自己个人根据自己实际出现的错误总结的东西了。 视频链接：https://www.bil
mybatis初步学习
qq_43667773的博客
11-28 205
目录 总结jdbc出现的问题 mybatis介绍 mybatis入门程序 占位符#{}与字符串拼接符${}区别 mybatis框架的原理 别名配置与映射文件加载方式 mybatis与hibernate的比较 一、总结jdbc出现的问题 1、准备数据库，执行mysql语句。 – Table structure for orders DROP TABLE IF EXISTS orders; CRE...
MyBatis初步使用（单表操作）
qq_36178165的博客
03-24 308
一、首先创建一web项目：我的叫MyBatisDo   先将需要的jar包导入到\WebRoot\WEB-INF\lib下。需要的两个包为：mybatis-3.2.2.jar和mysql-connector-java-5.1.0-bin.jar二、接下来是mybatis的配置文件设置首先在项目下新建一个resource文件夹（！！右击文件名，new-&gt;source floder），放置配置文...
mybatis的初步核心（一）
sinat_肖旭东的博客
10-08 435
1. 作为 一个 半自动的 数据库操作框架， mybts还是很有优势的， 好比 Ak47也是 半自动步枪，比起全自动的 hibernate 在复杂数据结果集有很大优势，    下面 给具体的 步骤，（纯mybts+xml配置） 2. 首先 导入 jar包      连接的 是 mysql 数据库。 3.配置 日志文件 log4j.rootLogger=debug,Console,Fil
mybatis初步demo
04-03
在这个"mybatis初步demo"中，我们可以深入学习MyBatis的基本概念和操作流程。以下是一些主要的知识点： 1. **配置文件**：MyBatis的核心配置文件（mybatis-config.xml）包含了数据源、事务管理器、...
Springboot - mybatis初步使用
07-24
本文用到的sql文件
spring-boot-mybatis 初步搭建
01-06
在本文中，我们将深入探讨如何初步搭建一个基于Spring Boot和MyBatis的Web应用程序。Spring Boot简化了Spring应用的初始化和配置，而MyBatis则是一个轻量级的持久层框架，它允许开发者通过简单的XML或注解来映射SQL...
MyBatis--初步创建-第一天--持续更新
qq_27752831的博客
06-29 245
1： 首先是导入Mybatis的jar包，以及object6（数据库）的jar包。 2： 然而是xml配置---放在src下    首先是config.properties文件作为基础 jdbc.jdbcUrl=jdbc:oracle:thin:@127.0.0.1:1521:orcl           //连接路径 jdbc.driverClass=oracle
我对的mybatis的初步理解
qq_43192337的博客
10-15 861
我对的mybatis的理解 mybatis本身是一个持久层的ORM框架，它封装了jdbc中注册驱动（Class.forName()），连接到数据库（Connection）、建立操作指令（Statement）、执行查询指令（executeQuery）、获得查询结果（ResultSet）等操作数据库的过程， ...
MyBatis的初步使用
xunming的专栏
05-30 1524
1、批量更新 &amp;amp;lt;update id=&amp;quot;batchUpdate&amp;quot; parameterType=&amp;quot;java.util.List&amp;quot;&amp;amp;gt; update test set test=${item.test}+1 where id in &amp;amp;lt;foreach collection=&amp;quot;list&a
MyBatis学习笔记（一）初步理解MyBatis是如何建立连接的
IcyDate的博客
04-01 1325
最近开始学习myBatis框架，为了不遗忘，所以将自己的浅显理解写下方便过后温习，写的很粗糙，见谅通过代码我们能看出myBatis建立连接用了四步String resource = "SqlMapConfig.xml"; InputStream is = Test3.class.getClassLoader().getResourceAsStream(resource); SqlSessi...
MyBatis+Spring在注解@Autowried后通过反射的方式调用方法获取注入的Service或DAO对象为空...
XinhuaShuDiao的博客
05-24 1124
        最近在做一个定时读取数据的功能，我的想法是能够动态的添加定时任务而不用重启系统，在网上也借阅了很多文章，但是都不够完整，因此通过网上的借鉴我自己整理了一份代码，系统采用的是Spring Boot+MyBatis。       通过Spring实现定时任务有2种方式： 一、通过注解@Scheduled，如@Scheduled(fixedRate = 1000 * 30)表示30...
基于Android音乐播放器设计与实现2.docx
最新发布
08-10
基于Android音乐播放器设计与实现2.docx
java基于ssm+jsp省出口基地公共信息服务平台系统源码 带毕业论文
08-10
【资源说明】 1、开发环境：ssm框架；内含Mysql数据库；JSP技术 2、该资源包括项目的全部源码，下载可以直接使用！ 3、本项目适合作为计算机、数学、电子信息等专业的课程设计、期末大作业和毕设项目，作为参考资料学习借鉴。 4、本资源作为“参考资料”如果需要实现其他功能，需要能看懂代码，并且热爱钻研，自行调试。
java spider.rar
08-10
java spider.rar
ASP校园学生信息在线管理系统设计(源代码+论文).rar
08-10
资源包主要包含以下内容： ASP项目源码：每个资源包中都包含完整的ASP项目源码，这些源码采用了经典的ASP技术开发，结构清晰、注释详细，帮助用户轻松理解整个项目的逻辑和实现方式。通过这些源码，用户可以学习到ASP的基本语法、服务器端脚本编写方法、数据库操作、用户权限管理等关键技术。 数据库设计文件：为了方便用户更好地理解系统的后台逻辑，每个项目中都附带了完整的数据库设计文件。这些文件通常包括数据库结构图、数据表设计文档，以及示例数据SQL脚本。用户可以通过这些文件快速搭建项目所需的数据库环境，并了解各个数据表之间的关系和作用。 详细的开发文档：每个资源包都附有详细的开发文档，文档内容包括项目背景介绍、功能模块说明、系统流程图、用户界面设计以及关键代码解析等。这些文档为用户提供了深入的学习材料，使得即便是从零开始的开发者也能逐步掌握项目开发的全过程。 项目演示与使用指南：为帮助用户更好地理解和使用这些ASP项目，每个资源包中都包含项目的演示文件和使用指南。演示文件通常以视频或图文形式展示项目的主要功能和操作流程，使用指南则详细说明了如何配置开发环境、部署项目以及常见问题的解决方法。 毕业设计参考：对于正在准备毕业设计的学生来说，这些资源包是绝佳的参考材料。每个项目不仅功能完善、结构清晰，还符合常见的毕业设计要求和标准。通过这些项目，学生可以学习到如何从零开始构建一个完整的Web系统，并积累丰富的项目经验。
MyBatis快速入门与进阶指南
通过以上步骤，你可以对MyBatis有初步的理解，并能开始实际应用。MyBatis因其灵活性和易用性，在实际项目中被广泛应用，它能够帮助开发者更高效地管理和操作数据库。随着深入学习，还可以掌握更多高级特性，如缓存、...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值