Mybatis框架学习

清疚 2022-12-31 04:21 133阅读 0赞

### 文章目录 ###

*  前言
 *  一、Mybatis是什么？
 *  二、Mybatis学习总结
 *   *  1.框架的底层实现技术-反射技术
     *  2.框架的底层实现技术-代理模式
     *  3.框架
     *  4.数据持久化
     *  5、Mybatis框架使用-xml方式1
     *  6、Xml方式1-CRUD操作
     *  7、配置日志
     *  8、Mybatis框架使用-xml方式2
     *  9、mybatis.cfg.xml核心配置文件详细说明
     *  10、映射文件配置详解
     *  11、模糊查询
     *  12、分页查询
     *  13、动态sql
     *  14、mybatis框架使用-注解方式（基本使用）
     *  15、mybatis框架使用-注解方式（动态sql）
     *  16、逆向工程
 *  总结

--------------------

# 前言 #

目前最主流的持久层框架为 hibernate 与 mybatis ，而且国内目前情况使用 Mybatis 的公司比 hibernate 要多。

**Hibernate的缺点**：a、学习门槛不低，要精通门槛更高。门槛高在怎么设计O/R映射，在性能和对象模型之间如何权衡取得平衡，以及怎样用好Hibernate缓存与数据加载策略方面。b、sql优化方面，Hibernate的查询会将表中的所有字段查询出来，这一点会有性能消耗。当然了，Hibernate也可以自己写SQL来指定需要查询的字段，但这样就破坏了Hibernate开发的简洁性。说得更深入一些，如果有个查询要关联多张表，比如5张表，10张表时，而且，我们要取的字段只是其中几张表的部分字段。这时用hibernate时就会显得非常力不从心。就算用hibernate的sqlquery，后续的维护工作也会让人发狂。

--------------------

# 一、Mybatis是什么？ #

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

# 二、Mybatis学习总结 #

## 1.框架的底层实现技术-反射技术 ##

（1）概念  
我们之前使用的都是我们已知的类，每个类中有哪些属性、方法、构造器我们都很清楚，直接调用即可。我们都是在编译之前使用的。  
如果在运行时，突然给你一个类，我们是不知道这个类的内容的，需要先了解这个类的内容，然后才能使用。这个过程我们叫反射。  
反射，在程序运行时，我们对未知类的探索和使用过程。  
（2）类加载器  
JVM在执行程序之前，需要先加载类，使用类加载器加载。

类加载器：  
核心类加载器-jdk/lib的java的核心jar包  
扩展类加载器-jdk/lib/ext的java的扩展jar包  
应用系统类加载器-我们项目引入的第三方jar包和我们写的class

加载顺序：核心类加载器–>扩展类加载器–>应用系统类加载器

加载使用“双亲委托模式”：  
首先，我们要运行程序，通过应用系统类加载器找到我们我们编写的类，交给扩展类加载器，然后扩展类加载器再交给核心类加载器。  
开始加载：核心类加载器先加载核心api，交给扩展类加载器继续加载扩展api，最后交给应用系统加载器加载剩下的api。  
如果这个类最后还没有加载，报ClassNotFoundException。  
（3）jvm内存分配  
JVM每加载一个类，都会创建一个Class对象，该对象中保存类的信息。Class对象在堆内存中。

（4）反射：通过Class对象获取类的内容。

代码如下：

package com.entity;
    
    //未知的类
    public class Student { 
    	private  int  a;
    	public   int  b;
    	
    	private  void  test1() { 
    		System.out.println(11);
    	}
    	
    	public  void  test2() { 
    		System.out.println(22);
    	}
    	
    	public Student() { 
    		System.out.println("null");
    	}
    
    	private Student(Integer a, Integer b) { 
    		super();
    		this.a = a;
    		this.b = b;
    	}
    	
    }

// 反射：获取类的内容
    // 第一步，获取这个类对应的Class对象
    // Class stuCls=Student.class;
    		Class  stuCls=Class.forName("com.entity.Student");
    // Student s=new Student();
    // Class stuCls=s.getClass();
    		
    // 第二步，通过Class对象，获取属性、方法、构造器
    // 获取构造器
    // 获取的公开的构造器
    		Constructor[]  cons=stuCls.getConstructors();
    // 获取所有的构造器
    		Constructor[]  consAll=stuCls.getDeclaredConstructors();
    // System.out.println(cons.length);
    // System.out.println(consAll.length);
    // 获取单个构造器
    		Constructor  nullCon=stuCls.getConstructor(null);
    		Constructor  con=stuCls.getConstructor(Integer.class,Integer.class);
    		
    // 获取方法：包括继承的
    // 获取的是公开的方法
    		Method[] methods = stuCls.getMethods();
    // 获取所有的方法
    		Method[] methodsAll = stuCls.getDeclaredMethods();
    // 获取单个方法
    		stuCls.getMethod("test1", null);
    		
    // 获取属性
    // 获取公开的属性
    		Field[] fields = stuCls.getFields();
    // 获取所有的属性
    		Field[] fieldsAll=stuCls.getDeclaredFields();
    // 获取单个属性
    		stuCls.getField("a");

// 反射：使用类的内容
    // 使用构造器创建对象
    		Student  stu1=(Student)nullCon.newInstance();
    		System.out.println(stu1.b);
    		
    // 使用它的方法解决问题
    		test2.invoke(stu1,null);
    		
    // 使用它的属性保存数据
    		b.setInt(stu1, 13);
    		System.out.println(b.getInt(stu1));

## 2.框架的底层实现技术-代理模式 ##

（1）理解  
代理(Proxy)是一种设计模式,提供了对目标对象另外的访问方式;即通过代理对象访问目标对象.这样做的好处是:可以在目标对象实现的基础上,增强额外的功能操作,即扩展目标对象的功能.  
这里使用到编程中的一个思想:不要随意去修改别人已经写好的代码或者方法,如果需改修改,可以通过代理的方式来扩展该方法

（2）代理方式  
静态代理  
JDK动态代理  
Cglib动态代理  
https://www.cnblogs.com/leeego-123/p/10995975.html  
（3）静态代理

代码如下：

package com.proxy;
    
    public interface IUserDao { 
        void save();
    }
    public class UserDao implements IUserDao { 
        public void save() { 
            System.out.println("----已经保存数据!----");
        }
    }
    
    package com.proxy;
    
    public class UserDaoProxy implements IUserDao{ 
    	//接收保存目标对象
        private IUserDao target;
        public UserDaoProxy(IUserDao target){ 
            this.target=target;
        }
    	@Override
    	public void save() { 
    		System.out.println("代理增强1");
    		//原来的功能
    		target.save();
    		System.out.println("代理增强2");
    	}
    }
    
    package com.proxy;
    
    public class TestStaticProxy { 
    
    	public static void main(String[] args) { 
    		IUserDao   old=new  UserDao();
    		IUserDao   proxy=new UserDaoProxy(old);
    
    		proxy.save();
    	}
    
    }

（4）JDK动态代理

package com.proxy.dyn;
    
    public interface IUserDao { 
        void save();
    }
    
    package com.proxy.dyn;
    
    public class UserDao implements IUserDao { 
        public void save() { 
            System.out.println("----已经保存数据!----");
        }
    }
    
    package com.proxy.dyn;
    
    import java.lang.reflect.InvocationHandler;
    import java.lang.reflect.Method;
    import java.lang.reflect.Proxy;
    
    public class ProxyFactory { 
    	//维护一个目标对象
        private Object target;
        public ProxyFactory(Object target){ 
            this.target=target;
        }
        
        //给目标对象生成代理对象
        public Object getProxyInstance(){ 
            return Proxy.newProxyInstance(
                    target.getClass().getClassLoader(),
                    target.getClass().getInterfaces(),
                    new InvocationHandler() { 
                        @Override
                        public Object invoke(Object proxy, Method method, Object[] args) throws Throwable { 
                            System.out.println("开始事务2");
                            //执行目标对象方法
                            Object returnValue = method.invoke(target, args);
                            System.out.println("提交事务2");
                            return returnValue;
                        }
                    }
            );
        }
    }
    
    package com.proxy.dyn;
    
    public class TestDynProxy { 
    
    	public static void main(String[] args) { 
    		IUserDao   target=new  UserDao();
    		ProxyFactory   factory=new  ProxyFactory(target);
    		IUserDao   proxy=(IUserDao)factory.getProxyInstance();
    		
    		proxy.save();
    	}
    
    }

（5）Cglib动态代理  
asm-3.3.jar  
cglib-2.2.jar  
导入cglib的相关jar包，注意版本冲突。  
目标对象不需要实现接口。

public class UserDao{ 
        public void save() { 
            System.out.println("----已经保存数据!----");
        }
    }
    package com.proxy.cglib;
    
    import java.lang.reflect.Method;
    
    import net.sf.cglib.proxy.Enhancer;
    import net.sf.cglib.proxy.MethodInterceptor;
    import net.sf.cglib.proxy.MethodProxy;
    
    /** * Cglib子类代理工厂 * 对UserDao在内存中动态构建一个子类对象 */
    public class ProxyFactory implements MethodInterceptor{ 
        //维护目标对象
        private Object target;
    
        public ProxyFactory(Object target) { 
            this.target = target;
        }
    
        //给目标对象创建一个代理对象
        public Object getProxyInstance(){ 
            //1.工具类
            Enhancer en = new Enhancer();
            //2.设置父类
            en.setSuperclass(target.getClass());
            //3.设置回调函数
            en.setCallback(this);
            //4.创建子类(代理对象)
            return en.create();
    
        }
    
        @Override
        public Object intercept(Object obj, Method method, Object[] args, MethodProxy proxy) throws Throwable { 
            System.out.println("开始事务...");
    
            //执行目标对象的方法
            Object returnValue = method.invoke(target, args);
            
            System.out.println("提交事务...");
    
            return returnValue;
        }
    }
    
    package com.proxy.cglib;
    
    public class TestCglibProxy { 
    	public static void main(String[] args) { 
    		
    		UserDao   target=new  UserDao();
    		
    		ProxyFactory  factory=new  ProxyFactory(target);
    		UserDao  proxy=(UserDao)factory.getProxyInstance();
    		
    		proxy.save();
    	}
    }

（6）spring aop  
spring aop 底层使用的是动态代理实现的。  
同时，支持两种动态代理。  
如果目标对象实现接口，采用jdk动态代理。  
如果目标对象没有实现接口，采用cglib动态代理。

## 3.框架 ##

（1）使用的角度看：写好的很多jar包  
（2）框架是一个半成品，提供了一些基础功能的封装、统一编码结构。  
（3）我们java学的框架有：  
全方位框架–spring框架  
持久化框架–Mybatis框架、Hibernate框架、spring data jpa、jdbcTemplate  
MVC框架–Spring MVC框架、Struts2、Struts1

## 4.数据持久化 ##

（1）解释  
数据持久化就是将内存中的数据模型转换为存储模型,以及将存储模型转换为内存中的数据模型的统称  
（2）我们一般使用数据库保存数据，我们主要做的是数据库的持久化操作。  
包含4项操作：增删改查。  
（3）jdbc  
（4）持久化框架  
Mybatis框架、Hibernate框架

面试题：Mybatis框架和Hibernate框架有什么区别？  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzYwNTI2Ng_size_16_color_FFFFFF_t_70]

（5）Mybatis封装了jdbc，替换jdbc数据持久化操作。

## 5、Mybatis框架使用-xml方式1 ##

（1）创建项目，下载和导入mybatis的jar包  
先导入数据库驱动包，然后导入mybatis核心包，还有mybatis的依赖包  
**Mybatis3.5.6需要使用mysql-connector-8.x-java.jar连接数据库**  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzYwNTI2Ng_size_16_color_FFFFFF_t_70 1]  
（2）在src下创建核心配置文件mybatis.cfg.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>
    	<environments default="mysql">
    		<environment id="mysql">
    			
    			<transactionManager type="JDBC"></transactionManager>
    			
    			<dataSource type="POOLED">
    				<property name="driver" value="com.mysql.cj.jdbc.Drvier"/>
    				<property name="url" value="jdbc:mysql://localhost:3306/test?serverTimezone=UTC"/>
    				<property name="username" value="root"/>
    				<property name="password" value="root"/>
    			</dataSource>
    		</environment>
    		
    	</environments>
    	
    	
    </configuration>

（3）创建com.mybatisTest.domain和实体类  
注意：属性名必须和列名相同，不区别大小写。

package com.mybatisTest.domain;
    
    public class Users { 
    	private  int  id;
    	private  String userName;
    	private  String pwd;
    	private  String  name;
    	private  String  tel;
    	public int getId() { 
    		return id;
    	}
    	public void setId(int id) { 
    		this.id = id;
    	}
    	public String getUserName() { 
    		return userName;
    	}
    	public void setUserName(String userName) { 
    		this.userName = userName;
    	}
    	public String getPwd() { 
    		return pwd;
    	}
    	public void setPwd(String pwd) { 
    		this.pwd = pwd;
    	}
    	public String getName() { 
    		return name;
    	}
    	public void setName(String name) { 
    		this.name = name;
    	}
    	public String getTel() { 
    		return tel;
    	}
    	public void setTel(String tel) { 
    		this.tel = tel;
    	}
    	public Users() { 
    		
    	}
    	private Users(int id, String userName, String pwd, String name, String tel) { 
    		super();
    		this.id = id;
    		this.userName = userName;
    		this.pwd = pwd;
    		this.name = name;
    		this.tel = tel;
    	}
    	@Override
    	public String toString() { 
    		return "Users [id=" + id + ", userName=" + userName + ", pwd=" + pwd + ", name=" + name + ", tel=" + tel + "]";
    	}
    	
    }

（4）在src下创建一个包com.mybatisTest.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">
      
    <mapper namespace="com.mybatisTest.mapper">
    	
    	<select id="findUserByUserName" parameterType="java.lang.String" resultType="com.mybatisTest.domain.Users">
    		select  *  from  users  where  username=#{ value}
    	</select>
    
    </mapper>

（5）修改mybatis.cfg.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>
    	<environments default="mysql">
    		<environment id="mysql">
    			
    			<transactionManager type="JDBC"></transactionManager>
    			
    			<dataSource type="POOLED">
    				<property name="driver" value="com.mysql.cj.jdbc.Driver"/>
    				<property name="url" value="jdbc:mysql://localhost:3306/test?serverTimezone=UTC"/>
    				<property name="username" value="root"/>
    				<property name="password" value="root"/>
    			</dataSource>
    		</environment>
    		
    	</environments>
    	
    	<mappers>
    		<mapper resource="com/mybatisTest/mapper/UsersMapper.xml"/>
    	</mappers>
    </configuration>

（6）获取连接，写个测试类

package com.mybatisTest.test;
    
    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;
    
    import com.mybatisTest.domain.Users;
    
    public class Test { 
    
    	public static void main(String[] args) throws Exception { 
    		String  xml="mybatis.cfg.xml";
    		InputStream  in=Resources.getResourceAsStream(xml);
    		
    		SqlSessionFactory  factory=new  SqlSessionFactoryBuilder().build(in);
    		SqlSession session=factory.openSession();
    		
    		Users  user = session.selectOne("com.mybatisTest.mapper.findUserByUserName","zhang3");
    		
    		System.out.println(user);
    		
    		session.close();
    	}
    
    }

## 6、Xml方式1-CRUD操作 ##

（1）添加数据

<insert id="addUser" parameterType="com.mybatisTest.domain.Users">
    		insert  into  users  values(null,#{ userName},#{ pwd},#{ name},#{ tel})
    	</insert>
    // 添加记录
    		Users  user=new  Users(2,"ziwei2","123456","ziwei","17810002000");
    		int i=session.insert("com.mybatisTest.mapper.addUser", user);
    		System.out.println(i);
    // 增删改需要提交，数据库才能生效
    		session.commit();

（2）查询一条数据

<select id="findUserById"  parameterType="java.lang.Integer" resultType="com.mybatisTest.domain.Users">
    		select  *  from  users  where  id=#{ value}	
    	</select>
    Users  user = session.selectOne("com.mybatisTest.mapper.findUserById",8);
    		System.out.println(user);

（3）查询多条数据

<select id="findAllUser" resultType="com.mybatisTest.domain.Users">
    		select *  from  users
    	</select>
    List<Users>  list=session.selectList("com.mybatisTest.mapper.findAllUser");
    		for (Users users : list) { 
    			System.out.println(users);
    		}

（4）修改数据

<update id="updateUserPwdById" parameterType="com.mybatisTest.domain.Users">
    		update  users  set  pwd=#{ pwd}  where  id=#{ id}
    	</update>
    // 修改
    		Users  user=new  Users(2,"ziwei2","6789","ziwei","17810002000");
    		session.update("com.mybatisTest.mapper.updateUserPwdById", user);

（5）删除数据

<delete id="deleteUserById" >
    		delete  from  users  where  id=#{ value}
    	</delete>
    // 删除
    		session.delete("deleteUserById",1);

## 7、配置日志 ##

（1）Mybatis内置的日志工厂提供日志功能，具体的日志实现有以下几种工具：  
SLF4J  
Apache Commons Logging  
Log4j 2  
Log4j  
JDK logging  
（2）日志级别  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzYwNTI2Ng_size_16_color_FFFFFF_t_70 2]  
我们开发时，用的日志打印级别debug，发布项目用的级别是info或error。

（3）在src下创建一个log4j.properties属性文件  
添加内容：

# \u5168\u5C40\u65E5\u5FD7\u914D\u7F6E
    log4j.rootLogger=DEBUG, stdout
    # \u63A7\u5236\u53F0\u8F93\u51FA
    log4j.appender.stdout=org.apache.log4j.ConsoleAppender
    log4j.appender.stdout.Target=System.err
    log4j.appender.stdout.layout=org.apache.log4j.PatternLayout
    log4j.appender.stdout.layout.ConversionPattern=%5p [%t] - %m%n

## 8、Mybatis框架使用-xml方式2 ##

（1）创建项目，导入jar包  
（2）创建核心配置文件mybatis.cfg.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>
    	<environments default="mysql">
    		<environment id="mysql">
    			
    			<transactionManager type="JDBC"></transactionManager>
    			
    			<dataSource type="POOLED">
    				<property name="driver" value="com.mysql.cj.jdbc.Driver"/>
    				<property name="url" value="jdbc:mysql://localhost:3306/test?serverTimezone=UTC"/>
    				<property name="username" value="root"/>
    				<property name="password" value="root"/>
    			</dataSource>
    		</environment>
    		
    	</environments>
    	
    	
    </configuration>

（2）创建核心配置文件mybatis.cfg.xml  
（3）创建实体类

package com.mybatisTest.domain;
    
    public class Users { 
    	private  int  id;
    	private  String userName;
    	private  String pwd;
    	private  String  name;
    	private  String  tel;
    	public int getId() { 
    		return id;
    	}
    	public void setId(int id) { 
    		this.id = id;
    	}
    	public String getUserName() { 
    		return userName;
    	}
    	public void setUserName(String userName) { 
    		this.userName = userName;
    	}
    	public String getPwd() { 
    		return pwd;
    	}
    	public void setPwd(String pwd) { 
    		this.pwd = pwd;
    	}
    	public String getName() { 
    		return name;
    	}
    	public void setName(String name) { 
    		this.name = name;
    	}
    	public String getTel() { 
    		return tel;
    	}
    	public void setTel(String tel) { 
    		this.tel = tel;
    	}
    	public Users() { 
    		
    	}
    	public Users(int id, String userName, String pwd, String name, String tel) { 
    		super();
    		this.id = id;
    		this.userName = userName;
    		this.pwd = pwd;
    		this.name = name;
    		this.tel = tel;
    	}
    	@Override
    	public String toString() { 
    		return "Users [id=" + id + ", userName=" + userName + ", pwd=" + pwd + ", name=" + name + ", tel=" + tel + "]";
    	}
    	
    }

（4）创建Mapper接口UsersMapper

package com.mybatisTest.mapper;
    
    import com.mybatisTest.domain.Users;
    
    public interface UsersMapper { 
    	
    	int  addUsers(Users  user);
    	
    }

（5）创建映射文件UsersMapper.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.mybatisTest.mapper.UsersMapper">
    	
    	
    	
    	<insert id="addUsers" parameterType="com.mybatisTest.domain.Users">
    		insert into users  values(null,#{ userName},#{ pwd},#{ name},#{ tel})
    	</insert>
    	
    </mapper>

（6）修改核心配置文件，添加映射。

<?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"></transactionManager>
    			
    			<dataSource type="POOLED">
    				<property name="driver" value="com.mysql.cj.jdbc.Driver"/>
    				<property name="url" value="jdbc:mysql://localhost:3306/test?serverTimezone=UTC"/>
    				<property name="username" value="root"/>
    				<property name="password" value="root"/>
    			</dataSource>
    		</environment>
    		
    	</environments>
    	
    	<mappers>
    		<mapper  resource="com/mybatisTest/mapper/UsersMapper.xml"/>
    	</mappers>
    </configuration>

（7）测试类

package com.mybatisTest.test;
    
    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;
    
    import com.mybatisTest.domain.Users;
    import com.mybatisTest.mapper.UsersMapper;
    
    public class Test { 
    
    	public static void main(String[] args) throws Exception { 
    		String  xml="mybatis.cfg.xml";
    		InputStream  in=Resources.getResourceAsStream(xml);
    		SqlSessionFactory factory = new  SqlSessionFactoryBuilder().build(in);
    		SqlSession session = factory.openSession();
    		
    // 返回一个接口的代理实现类对象
    		UsersMapper mapper = session.getMapper(UsersMapper.class);
    		Users  user=new  Users(0, "十号", "555", "世豪", "15010002000");
    		int  i=mapper.addUsers(user);
    		System.out.println(i);
    		
    		session.commit();
    		session.close();
    	}
    
    }

（8）工具类封装

package com.mybatisTest.util;
    
    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 SessionFactory { 
    	private static   SqlSessionFactory   ssf;
    	static{ 
    		String  xml="mybatis.cfg.xml";
    		InputStream in=null;
    		try { 
    			in = Resources.getResourceAsStream(xml);
    		} catch (IOException e) { 
    			e.printStackTrace();
    		}
    		ssf = new  SqlSessionFactoryBuilder().build(in);
    	}
    	
    	public  static  SqlSession  getSqlSession() { 
    		return  ssf.openSession();
    	}
    	
    }

## 9、mybatis.cfg.xml核心配置文件详细说明 ##

（1）properties  
加载属性文件

（2）settings  
设置mybatis的全局属性

（3）typeAliases  
为了在映射文件中写起来简单，我们可以给引用的类起别名。

（4）plugins  
mybatis引入的插件设置（后续用到再说）

（5）Environments  
配置数据源，可以配置多个数据源，使用default指定采用哪个数据源

<environments default="mysql">
    		<environment id="mysql">
    			
    			
    			
    			
    			<transactionManager type="JDBC"></transactionManager>
    			
    			
    			
    			
    			<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>

（6）mappers

加载映射文件
    <mapper  resource="com/mybatisTest/mapper/UsersMapper.xml"/>
    <mapper class="com.mybatisTest.mapper.UsersMapper"/>
    
    <package name="com.mybatisTest.mapper"/>
    
    <mapper url=""/>

## 10、映射文件配置详解 ##

（1）映射文件名称  
可以任意指定。  
建议使用mapper接口名命名。  
如果没有接口，采用实体类名+Mapper.xml。  
（2）namespace  
指定我们配置的sql放在哪个空间下存储。  
一般建议使用mapper接口的全名。  
如果没有接口，可以任意指定，建议使用文件所在的包名+文件名。  
（3）sql的id  
和接口的方法名相同。  
没有接口，任意指定。  
（4）sql的参数类型  
参数类型主要有：简单类型，实体类型，Map类型  
推荐使用parameterType指定，不推荐parameterMap

简单类型：parameterType=”java.lang.String”  
实体类型：parameterType=”com.mybatisTest.domain.Users”  
Map类型：parameterType=”java.util.Map”

（5）返回值类型  
返回值类型主要有：简单类型、实体类型、List集合

可以使用两种方式指定：resultType和resultMap

集合只要指定元素的类型  
resultType=”com.mybatisTest.domain.Users”

resultMap：  
第一种，结果集的列名和实体类的属性名不相同。  
第二种，多表查询。

<resultMap type="com.mybatisTest.domain.Users" id="usersMap">
    		<id  column="id"  property="id"></id>
    		<result column="username"  property="userName2"/>
    		<result column="pwd"  property="pwd"/>
    		<result column="name"  property="name"/>
    		<result  column="tel"  property="tel"/>
    	</resultMap>
    	
    	<select id="findAll"  resultMap="usersMap">
    		select *  from  users
    	</select>

（6）Sql中使用$\{\}和\#\{\}区别  
\#底层用的sql对象PreparedStatement。  
Sql使用预处理方式生成，\#\{\}相当于?,可以防止sql注入风险。  
简单类型：使用\#\{任意符号\}获取

$ 底层用的sql对象Statement。  
Sql使用字符串拼接，有sql注入风险。  
简单类型：使用$\{value\}获取

我们推荐使用\#\{\}，不推荐$\{\}.

package com.mybatisTest.domain;
    
    public class Fruit { 
    	private  int  id;
    	private  String name;
    	public int getId() { 
    		return id;
    	}
    	public void setId(int id) { 
    		this.id = id;
    	}
    	public String getName() { 
    		return name;
    	}
    	public void setName(String name) { 
    		this.name = name;
    	}
    	public Fruit() { 
    		// TODO Auto-generated constructor stub
    	}
    	public Fruit(int id, String name) { 
    		super();
    		this.id = id;
    		this.name = name;
    	}
    	@Override
    	public String toString() { 
    		return "Fruit [id=" + id + ", name=" + name + "]";
    	}
    }
    
    package com.mybatisTest.mapper;
    
    import java.util.List;
    import java.util.Map;
    
    import com.mybatisTest.domain.Fruit;
    
    public interface FruitMapper { 
    	int  addFruit(Fruit  ft);
    	int  addFruit2(Map  m);
    	Fruit  findFruitById(int  id);
    	List<Fruit>  findAllFruit();
    }
    
    <?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.mybatisTest.mapper.FruitMapper">
    
    	<insert id="addFruit2"  parameterType="map">
     		insert into  fruit  values(null,'${fname}')
     		
     	</insert>
     	
     	<insert id="addFruit"  parameterType="com.mybatisTest.domain.Fruit">
     		insert into  fruit  values(null,'${name}')
     		insert into  fruit  values(null,#{ name})
     	</insert>
     	
     	<select id="findFruitById" parameterType="int" resultType="com.mybatisTest.domain.Fruit">
     		
     		select *  from  fruit  where  id=#{ aa} 
     	</select>
     	
    </mapper>  
    package com.mybatisTest.test;
    
    import java.util.HashMap;
    import java.util.Map;
    
    import org.apache.ibatis.session.SqlSession;
    
    import com.mybatisTest.mapper.FruitMapper;
    import com.mybatisTest.util.SessionFactory;
    
    public class TestFruit { 
    
    	public static void main(String[] args) { 
    		SqlSession   session=SessionFactory.getSqlSession();
    		
    		FruitMapper  fm=session.getMapper(FruitMapper.class);
    		//添加水果
    // Fruit ft=new Fruit(0,"apple");
    // fm.addFruit(ft);
    		
    		Map  m=new  HashMap();
    		m.put("fname", "人参果");
    		fm.addFruit2(m);
    		
    		//通过id，查询水果
    // Fruit f = fm.findFruitById(3);
    // System.out.println(f);
    		
    		session.commit();
    		session.close();
    	}
    
    }

## 11、模糊查询 ##

（1）第一种方式：拼好再传参  
Mapper接口：

//模糊查询1
    	List<Fruit>   findFruitLikeName(String  name);

Mapper映射：

<select id="findFruitLikeName"  resultType="com.mybatisTest.domain.Fruit">
     		select *   from  fruit  where  name  like #{ value}
     	</select>

// 模糊查询1
    		List<Fruit> likeList = fm.findFruitLikeName("%a%");
    		for (Fruit fruit : likeList) { 
    			System.out.println(fruit);
    		}

第二种，传参后再拼sql(推荐)

//模糊查询2 
    	List<Fruit>   findFruitLikeName2(String  name);
    
     	<select id="findFruitLikeName2"  resultType="com.mybatisTest.domain.Fruit">
     		select *   from  fruit  where  name  like "%"#{ value}"%"
     		
     	</select>

// 模糊查询2
    		List<Fruit> likeList = fm.findFruitLikeName2("a");
    		for (Fruit fruit : likeList) { 
    			System.out.println(fruit);
    		}

第三种，使用$

## 12、分页查询 ##

（1）分页查询分两大类  
一类，通过sql在数据库中分页，直接返回一页数据。  
另一类，查询所有数据，然后在内存中取出指定的一页数据。

（2）sql分页  
Mysql数据库：limit 起始位置,每页的数量  
Oracle数据库：rownum，需要知道起始位置和结束位置

以mysql为例：  
前端页面传给应用服务器的信息是pageNum，pageSize；  
计算：起始位置start=（pageNum-1）\*pageSize,每页的数量pageSize  
最后将start和pageSize传给sql。

//sql分页
    	List<Fruit>   findFruitPage(Map page);
    
     	<select id="findFruitPage" parameterType="map" resultType="com.mybatisTest.domain.Fruit">
     		select *  from  fruit  limit   #{ start},#{ pageSize}
     	</select>
    // sql分页
    		int  pageNum=2;
    		int  pageSize=3;
    		
    		//计算
    		int  start=(pageNum-1)*pageSize;
    		
    		//传给sql
    		Map  m=new  HashMap();
    		m.put("start",start);
    		m.put("pageSize",pageSize);
    		
    		List<Fruit> pages = fm.findFruitPage(m);
    		for (Fruit fruit : pages) { 
    			System.out.println(fruit);
    		}

（3）内存分页

//内存分页RowBounds
    	List<Fruit>  findAllFruitPage(String  name,RowBounds rb);
    
     	<select id="findAllFruitPage" parameterType="string" resultType="com.mybatisTest.domain.Fruit">
     		select *  from  fruit where  name=#{ value}
     	</select>
    // 内存分页RowBounds，查询水果
    		List<Fruit> pages = fm.findAllFruitPage("apple",new  RowBounds(3, 4));
    		for (Fruit fruit : pages) { 
    			System.out.println(fruit);
    		}

（4）分页插件（PageHelper）  
内存分页  
（5）分页拦截器（Interceptor）  
Sql分页

## 13、动态sql ##

我们前面的项目需要实现多条件查询，你输入哪个字段就用哪个字段查询。  
需要使用标签：  
if where set forEach trim

案例：

package com.mybatisTest.domain;
    
    public class Product { 
    	private  int  id;
    	private  String  name;
    	private  String  brand;
    	private  String  merchant;
    	public int getId() { 
    		return id;
    	}
    	public void setId(int id) { 
    		this.id = id;
    	}
    	public String getName() { 
    		return name;
    	}
    	public void setName(String name) { 
    		this.name = name;
    	}
    	public String getBrand() { 
    		return brand;
    	}
    	public void setBrand(String brand) { 
    		this.brand = brand;
    	}
    	public String getMerchant() { 
    		return merchant;
    	}
    	public void setMerchant(String merchant) { 
    		this.merchant = merchant;
    	}
    }
    
    package com.mybatisTest.mapper;
    
    import java.util.List;
    import java.util.Map;
    
    import com.mybatisTest.domain.Product;
    
    public interface ProductMapper { 
    	
    // 多条件查询方法
    	List<Product>  findByMore(Product  p);
    	
    	List<Product>  findByMore2(Map  m);
    }
    
    <?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.mybatisTest.mapper.ProductMapper">
    	
    	<select id="findByMore" parameterType="com.mybatisTest.domain.Product" resultType="com.mybatisTest.domain.Product">
    		select *  from  product
    		
    		<where>
    			<if  test="name!=null">
    				and  name=#{ name}
    			</if>
    			<if test="brand!=null">
    				and  brand=#{ brand}
    			</if>
    			<if test="merchant!=null">
    				and  merchant=#{ merchant}
    			</if>
    		</where>
    	</select>
    	
    	
    	<select id="findByMore2"  parameterType="map"  resultType="com.mybatisTest.domain.Product">
    		select *  from  product  where  id  in
    		<foreach collection="list"  item="pp"  open="(" separator=","  close=")">
    			#{ pp}
    		</foreach>
    	</select>
    </mapper>  
      
      
    package com.mybatisTest.test;
    
    import java.util.ArrayList;
    import java.util.HashMap;
    import java.util.List;
    import java.util.Map;
    
    import org.apache.ibatis.session.SqlSession;
    
    import com.mybatisTest.domain.Product;
    import com.mybatisTest.mapper.ProductMapper;
    import com.mybatisTest.util.SessionFactory;
    
    public class TestProduct { 
    	public static void main(String[] args) { 
    		
    		SqlSession sqlSession = SessionFactory.getSqlSession();
    		ProductMapper mapper = sqlSession.getMapper(ProductMapper.class);
    		
    		
    // //设置查询条件
    // Product p=new Product();
    // p.setName("iphone12");
    // p.setBrand("apple");
    // //查询操作
    // List<Product> findByMore = mapper.findByMore(p);
    // for (Product product : findByMore) { 
    // System.out.println(product);
    // }
    		
    		Map   m=new  HashMap();
    		List  list=new  ArrayList();
    		list.add(1);
    		list.add(2);
    		m.put("list", list);
    		List<Product> more2 = mapper.findByMore2(m);
    		for (Product product : more2) { 
    			System.out.println(product);
    		}
    		
    		sqlSession.close();
    	}
    }

## 14、mybatis框架使用-注解方式（基本使用） ##

（1）加载mybatis相关jar  
（2）创建核心配置文件mybatis.cfg.xml  
（3）创建实体类

package mybatisTest4.domain;
    
    import java.util.Date;
    
    public class Goods { 
    	private  int  id;
    	private  String  name;
    	private  String  brand;
    	private  double  price;
    	private  int     count;
    	private  Date    birthdate;
    	private  String  info;
    	public int getId() { 
    		return id;
    	}
    	public void setId(int id) { 
    		this.id = id;
    	}
    	public String getName() { 
    		return name;
    	}
    	public void setName(String name) { 
    		this.name = name;
    	}
    	public String getBrand() { 
    		return brand;
    	}
    	public void setBrand(String brand) { 
    		this.brand = brand;
    	}
    	public double getPrice() { 
    		return price;
    	}
    	public void setPrice(double price) { 
    		this.price = price;
    	}
    	public int getCount() { 
    		return count;
    	}
    	public void setCount(int count) { 
    		this.count = count;
    	}
    	public Date getBirthdate() { 
    		return birthdate;
    	}
    	public void setBirthdate(Date birthdate) { 
    		this.birthdate = birthdate;
    	}
    	public String getInfo() { 
    		return info;
    	}
    	public void setInfo(String info) { 
    		this.info = info;
    	}
    	public Goods() { 
    		
    	}
    	public Goods(String name, String brand, double price, int count, Date birthdate, String info) { 
    		super();
    		this.name = name;
    		this.brand = brand;
    		this.price = price;
    		this.count = count;
    		this.birthdate = birthdate;
    		this.info = info;
    	}
    	public Goods(int id, String name, String brand, double price, int count, Date birthdate, String info) { 
    		super();
    		this.id = id;
    		this.name = name;
    		this.brand = brand;
    		this.price = price;
    		this.count = count;
    		this.birthdate = birthdate;
    		this.info = info;
    	}
    	
    }

（4）创建mapper接口（使用注解定义sql）

package mybatisTest4.mapper;
    
    import java.util.List;
    
    import org.apache.ibatis.annotations.Delete;
    import org.apache.ibatis.annotations.Insert;
    import org.apache.ibatis.annotations.Select;
    import org.apache.ibatis.annotations.Update;
    
    import mybatisTest4.domain.Goods;
    
    /** * 定义操作数据库的方法 * @author Administrator */
    public interface GoodsMapper { 
    // 添加商品
    	@Insert("insert into goods values(null,#{name},#{brand},#{price},#{count},#{birthdate},#{info})")
    	int addGoods(Goods  goods);
    // 删除商品
    	@Delete("delete from goods where id=#{id}")
    	int deleteGoods(int  id);
    // 修改商品
    	@Update("update goods set name=#{name} where id=#{id}")
    	int updateGoods(Goods  goods);
    // 查询一个商品
    	@Select("select * from goods where id=#{id}")
    	Goods  findGoodsById(int  id);
    // 查询所有商品
    	@Select("select * from goods")
    	List<Goods>  findAllGoods();
    }

（5）业务测试类：

package mybatisTest4.service.impl;
    
    
    import java.util.Date;
    
    import org.apache.ibatis.session.SqlSession;
    
    import mybatisTest4.domain.Goods;
    import mybatisTest4.mapper.GoodsMapper;
    import mybatisTest4.util.SessionFactory;
    
    public class GoodsServiceImpl { 
    	
    	public  int addGoods(Goods  goods) { 
    		SqlSession sqlSession = SessionFactory.getSqlSession();
    		GoodsMapper mapper = sqlSession.getMapper(GoodsMapper.class);
    		
    		int  i=mapper.addGoods(goods);
    		
    		sqlSession.commit();
    		sqlSession.close();
    		return  i;
    	}  
    	
    	
    	public static void main(String[] args) { 
    		
    		GoodsServiceImpl  service=new  GoodsServiceImpl();
    		Goods  goods=new  Goods("rongyaoplay", "rongyao", 1000, 1000, new Date(), "曾经是华为，现在是荣耀");
    		service.addGoods(goods);
    	}
    }

## 15、mybatis框架使用-注解方式（动态sql） ##

（1）复杂sql  
我们可以使用sql拼接，更建议使用：  
InsertProvider  
DeleteProvider  
UpdateProvider  
SelectProvider

需要先写一个sql类，用于sql的获取。  
然后在接口中是Provider注解指定sql 来源于那个类的那个方法。

package mybatisTest4.sql;
    
    import org.apache.ibatis.jdbc.SQL;
    
    import com.sun.org.apache.bcel.internal.generic.IFNULL;
    
    import mybatisTest4.domain.Goods;
    
    public class GoodsSql { 
    	
    	public String updateGoods3(Goods  goods) { 
    		return  new  SQL() { { 
    			UPDATE("goods");
    			if(goods.getName()!=null&&!goods.getName().trim().equals("")) { 
    				SET("name=#{name}");
    			}
    			if(goods.getBrand()!=null&&!goods.getBrand().trim().equals("")) { 
    				SET("brand=#{brand}");
    			}
    			WHERE("id=#{id}");
    		}}.toString();
    	}
    	
    	public String  findGoodsMoreLike(Goods  goods) { 
    		return  new  SQL() { { 
    			SELECT("*");
    			FROM("goods");
    			if(goods.getName()!=null&&!goods.getName().trim().equals("")) { 
    				AND().WHERE("name like \"%\"#{name}\"%\"");
    			}
    			if(goods.getBrand()!=null&&!goods.getBrand().trim().equals("")) { 
    				AND().WHERE("brand like \"%\"#{brand}\"%\"");
    			}
    		}}.toString();
    	}
    }
    
    package mybatisTest4.mapper;
    
    import java.util.List;
    
    import org.apache.ibatis.annotations.Delete;
    import org.apache.ibatis.annotations.Insert;
    import org.apache.ibatis.annotations.Param;
    import org.apache.ibatis.annotations.Select;
    import org.apache.ibatis.annotations.Update;
    import org.apache.ibatis.annotations.UpdateProvider;
    
    import mybatisTest4.domain.Goods;
    import mybatisTest4.sql.GoodsSql;
    
    /** * 定义操作数据库的方法 * @author Administrator */
    public interface GoodsMapper { 
    // 修改商品
    	@UpdateProvider(type=GoodsSql.class,method="updateGoods3")
    	int updateGoods3(Goods  goods);
    }

（2）resultMap  
解决结果映射中属性和列名不同的现象。

@Results(id="goodsMap",value= { 
    			@Result(column="id",property="id",id=true),
    			@Result(column="name",property="name"),
    			@Result(column="brand",property="brand"),
    			@Result(column="price",property="price"),
    			@Result(column="count",property="count"),
    			@Result(column="birthdate",property="birthdate"),
    			@Result(column="info",property="info")
    	})

## 16、逆向工程 ##

（1）使用mybatis-generator-core插件  
（2）下载和导入jar包  
https://github.com/mybatis/generator/releases

mybatis-generator-core-1.4.0-javadoc.jar  
mybatis-generator-core-1.4.0-sources.jar  
mybatis-generator-core-1.4.0.jar

（3）Src配置一个文件generatorConfig.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>
       <classPathEntry location="D:\hd2011\mybatisTest4\WebContent\WEB-INF\lib\mysql-connector-java-8.0.22.jar" />
       <context id="msqlTables" targetRuntime="MyBatis3">
      <plugin type="org.mybatis.generator.plugins.SerializablePlugin"></plugin>
        <jdbcConnection connectionURL="jdbc:mysql://localhost:3306/test?serverTimezone=UTC"
         driverClass="com.mysql.cj.jdbc.Driver" password="root" userId="root" >
    
        <property name="nullCatalogMeansCurrent" value="true"/>
        </jdbcConnection>
        <javaTypeResolver>
                <property name="forceBigDecimals" value="false" />
            </javaTypeResolver>
        <javaModelGenerator targetPackage="com.springdemo.model" targetProject="mybatis_generator\src">
                <property name="enableSubPackages" value="true"/>
                
                <property name="trimStrings" value="true" />
            </javaModelGenerator>
         <sqlMapGenerator targetPackage="mapping" targetProject="mybatis_generator\src">
                <property name="enableSubPackages" value="true"/>
            </sqlMapGenerator>
        <javaClientGenerator type="XMLMAPPER" targetPackage="com.springdemo.dao" targetProject="mybatis_generator\src">
                <property name="enableSubPackages" value="true"/>
        </javaClientGenerator>
    
              
              <table tableName="goods" domainObjectName="Goods"
                   enableCountByExample="false" enableUpdateByExample="false" enableDeleteByExample="false"
                   enableSelectByExample="false" selectByExampleQueryId="false" >
                <property name="useActualColumnNames" value="false"/>
            </table>
      </context>
    </generatorConfiguration>

（4）使用教程：  
使用eclipse插件，自动生成代码。  
https://www.cnblogs.com/xqz0618/p/javaweb05.html

--------------------

# 总结 #

待。。。。。。。。。。。。。。。

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzYwNTI2Ng_size_16_color_FFFFFF_t_70]: /images/20221120/61bb0c7a093144e4b2154946861a1a84.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzYwNTI2Ng_size_16_color_FFFFFF_t_70 1]: /images/20221120/d885a129b7fa425bad276b53e8e21daa.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzYwNTI2Ng_size_16_color_FFFFFF_t_70 2]: /images/20221120/5854d8bd8fdb4126b1aef5f2815bb87e.png