MyBatis系列第九篇:MyBatis插件

最新推荐文章于 2024-02-22 07:32:17 发布
最新推荐文章于 2024-02-22 07:32:17 发布
阅读量444 收藏 3
点赞数
分类专栏： MyBatis 文章标签： mybatis
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_29445811/article/details/117329688
版权

文章目录

一、插件原理

MyBatis 在 四大对象的创建过程中，都会有插件进行介入。插件可以利用动态代理机制一层层的包装目标对象，而实现在目标对象执行目标方法之前进行拦截的效果。

MyBatis 允许在已映射语句执行过程中的某一点进行拦截调用。

默认情况下，MyBatis 允许使用插件来拦截的方法调用包括：四大对象

 Executor (update, query, flushStatements, commit, rollback,getTransaction, close, isClosed)
 ParameterHandler (getParameterObject, setParameters)
 ResultSetHandler (handleResultSets, handleOutputParameters)
 StatementHandler (prepare, parameterize, batch, update, query)

1、创建四大对象的ParameterHandler

BaseStatementHandler.java
  protected BaseStatementHandler(Executor executor, MappedStatement mappedStatement, Object parameterObject, RowBounds rowBounds, ResultHandler resultHandler, BoundSql boundSql) {
    this.configuration = mappedStatement.getConfiguration();
    this.executor = executor;
    this.mappedStatement = mappedStatement;
    this.rowBounds = rowBounds;

    this.typeHandlerRegistry = configuration.getTypeHandlerRegistry();
    this.objectFactory = configuration.getObjectFactory();

    if (boundSql == null) { // issue #435, get the key before calculating the statement
      generateKeys(parameterObject);
      boundSql = mappedStatement.getBoundSql(parameterObject);
    }

    this.boundSql = boundSql;

    this.parameterHandler = configuration.newParameterHandler(mappedStatement, parameterObject, boundSql);
    this.resultSetHandler = configuration.newResultSetHandler(executor, mappedStatement, rowBounds, parameterHandler, resultHandler, boundSql);
  }

2、每个创建出来的对象不是直接返回的，而是调用pluginAll()

  public ParameterHandler newParameterHandler(MappedStatement mappedStatement, Object parameterObject, BoundSql boundSql) {
    ParameterHandler parameterHandler = mappedStatement.getLang().createParameterHandler(mappedStatement, parameterObject, boundSql);
    parameterHandler = (ParameterHandler) interceptorChain.pluginAll(parameterHandler);
    return parameterHandler;
  }

  public Object pluginAll(Object target) {
    for (Interceptor interceptor : interceptors) {
      target = interceptor.plugin(target);
    }
    return target;
  }

插件原理
在四大对象创建的时候

1、每个创建出来的对象不是直接返回的，而是调用pluginAll()返回

2、获取所有的interceptor(拦截器)（插件需要实现的接口）调用interceptor.plugin(target);返回target包装后的对象

3、插件机制、我们可以使用插件为目标对象创建一个代理对象（AOP动态代理）

我们的插件可以为四大对象创建出代理对象
代理对象可以拦截到四大对象的每一个执行方法

插件执行流程
1、按照插件注解声明，按照插件配置顺序调用插件plugin方法，生成被拦截对象的动态代理
2、多个插件依次生成目标对象的代理对象，层层包裹，先声明的先包裹；形成代理链
3、目标方法执行时依次从外到内执行插件的intercept方法。
在这里插入图片描述

4、多个插件情况下，我们往往需要在某个插件中分离出目标对象。可以借助MyBatis提供的SystemMetaObject类来进行获取最后一层的h以及target属性的值

二、插件开发

1.插件开发步骤

1、编写Interceptor接口的实现类

package com.ming.plugin;

import org.apache.ibatis.executor.statement.StatementHandler;
import org.apache.ibatis.plugin.*;

import java.sql.Statement;
import java.util.Properties;

/**
 *
 *
 * 使用@Intercepts注解完成插件签名：告诉mybatis当前插件用来拦截哪个对象的哪个方法
 */
//type:拦截的四大对象之一StatementHandler（处理SQL语句预编译设置参数），method:对象的方法（parameterize设置参数） args:对象参数的列表
@Intercepts(
        {
             @Signature(type = StatementHandler.class,method ="parameterize",args = Statement.class)
        })
public class MyPlugin implements Interceptor{

    /**
     * 拦截目标对象的目标方法的执行
     * @param invocation
     * @return
     * @throws Throwable
     */
    @Override
    public Object intercept(Invocation invocation) throws Throwable {
        System.out.println("MyPlugin....intercept:自定义插件拦截的目标方法"+invocation.getMethod());
        //放行、执行目标方法
        Object proceed = invocation.proceed();
        //返回执行后的返回值
        return proceed;
    }

    /**
     * plugin:包装目标对象的，所谓的包装就是为目标对象创建代理对象
     * @param target
     * @return
     */
    @Override
    public Object plugin(Object target) {
        System.out.println("MyPlugin...四大对象创建的时候被调用....plugin:Mybatis将要包装的对象"+target);
        //可以借助 Plugin.wrap()方法使用当前的Intercept包装我们目标对象
        Object wrap = Plugin.wrap(target,this);

        //返回为当前target创建的动态代理
        return wrap;
    }

    /**
     * 将插件注册时的Property属性设置进来
     * @param properties
     */
    @Override
    public void setProperties(Properties properties) {
        System.out.println("插件配置的信息properties："+properties);
    }


}

2、使用@Intercepts完成插件签名

3、将写好的插件注册到全局配置文件中

    <!-- 注册插件property 属性会被插件的获取到-->
    <plugins>
        <plugin interceptor="com.ming.plugin.MyPlugin">
            <property name="username" value="root"/>
            <property name="password" value="123456"/>
        </plugin>
    </plugins>

测试运行一个查询方法

    @Test
    public void testInterface() throws IOException {
        SqlSessionFactory sqlSessionFactory = getSqlSessionFactory();
        SqlSession sqlSession = sqlSessionFactory.openSession();
        try {
            EmployeeMapper employeeMapper = sqlSession.getMapper(EmployeeMapper.class);
            Employee employee = employeeMapper.getEmpByID(1);
            System.out.println(employee);
            Employee employee2 = employeeMapper.getEmpByID(5);
            System.out.println(employee2);
            System.out.println(employee==employee2);

        }finally {
            sqlSession.close();
        }
    }


MyPlugin...四大对象创建的时候被调用....plugin:Mybatis将要包装的对象org.apache.ibatis.executor.CachingExecutor@3f197a46
DEBUG 05-27 17:04:35,300 Cache Hit Ratio [com.ming.dao.EmployeeMapper]: 0.0  (LoggingCache.java:62) 
MyPlugin...四大对象创建的时候被调用....plugin:Mybatis将要包装的对象org.apache.ibatis.scripting.defaults.DefaultParameterHandler@5b239d7d
MyPlugin...四大对象创建的时候被调用....plugin:Mybatis将要包装的对象org.apache.ibatis.executor.resultset.DefaultResultSetHandler@6d763516
MyPlugin...四大对象创建的时候被调用....plugin:Mybatis将要包装的对象org.apache.ibatis.executor.statement.RoutingStatementHandler@37afeb11
DEBUG 05-27 17:04:35,305 ==>  Preparing: select id,last_name AS lastName,gender,email from tbl_employee WHERE id = ?   (BaseJdbcLogger.java:145) 
MyPlugin....intercept:自定义插件拦截的目标方法public abstract void org.apache.ibatis.executor.statement.StatementHandler.parameterize(java.sql.Statement) throws java.sql.SQLException
DEBUG 05-27 17:04:35,319 ==> Parameters: 1(Integer)  (BaseJdbcLogger.java:145)

多个插件运行的流程

左一单个插件代理对象 右一多个插件代理对象
在这里插入图片描述

2.Interceptor接口

常用代码：从代理链中分离真实被代理对象

//1、分离代理对象。由于会形成多次代理，所以需要通过一个
while 循环分离出最终被代理对象，从而方便提取信息
MetaObject metaObject = SystemMetaObject. forObject(target);
e while  (metaObject.hasGetter( "h" )) {
Object h = metaObject.getValue("h");
metaObject = SystemMetaObject. forObject(h);
}
//2、获取到代理对象中包含的被代理的真实对象
Object obj = metaObject.getValue("target");
//3、获取被代理对象的MetaObject方便进行信息提取
MetaObject forObject = SystemMetaObject. forObject(obj);

可以在目标方法放行前后做一些操作、动态修改mybatis运行流程

比如：动态改变sql运行的参数、比如以前查询id为1的员工、实际从数据库查询3号员工

package com.ming.plugin;

import org.apache.ibatis.executor.statement.StatementHandler;
import org.apache.ibatis.plugin.*;
import org.apache.ibatis.reflection.MetaObject;
import org.apache.ibatis.reflection.SystemMetaObject;

import java.sql.Statement;
import java.util.Properties;

/**
 *
 *
 * 使用@Intercepts注解完成插件签名：告诉mybatis当前插件用来拦截哪个对象的哪个方法
 */
//type:拦截的四大对象之一StatementHandler（处理SQL语句预编译设置参数），method:对象的方法（parameterize设置参数） args:对象参数的列表
@Intercepts(
        {
             @Signature(type = StatementHandler.class,method ="parameterize",args = Statement.class)
        })
public class MyPlugin implements Interceptor{

    /**
     * 拦截目标对象的目标方法的执行
     * @param invocation
     * @return
     * @throws Throwable
     */
    @Override
    public Object intercept(Invocation invocation) throws Throwable {
        System.out.println("MyPlugin....intercept:自定义插件拦截的目标方法"+invocation.getMethod());
        //intercept()可以在目标方法放行前后做一些操作、动态修改mybatis运行流程
        //操作：动态改变sql运行的参数、比如以前查询id为1的员工、实际从数据库查询3号员工
        //拿到StatementHandler-->ParameterHandler->parameterObject的值
        //拦截到的目标对象
        Object target = invocation.getTarget();
        //拿到target元数据
        System.out.println("拦截到的目标对象："+invocation.getTarget());
        //1、分离代理对象。由于会形成多次代理，所以需要通过一个 while 循环分离出最终被代理对象，从而方便提取信息
        MetaObject metaObject = SystemMetaObject.forObject(target);
        //2、获取到代理对象中包含的被代理的真实对象
        Object value = metaObject.getValue("parameterHandler.parameterObject");
        System.out.println("sql语句用的参数是："+value);
        //修改完sql语句要用的参数
        metaObject.setValue("parameterHandler.parameterObject","5");


        //放行、执行目标方法
        Object proceed = invocation.proceed();
        //返回执行后的返回值
        return proceed;
    }

    /**
     * plugin:包装目标对象的，所谓的包装就是为目标对象创建代理对象
     * @param target
     * @return
     */
    @Override
    public Object plugin(Object target) {
        System.out.println("MyPlugin...四大对象创建的时候被调用....plugin:Mybatis将要包装的对象"+target);
        //可以借助 Plugin.wrap()方法使用当前的Intercept包装我们目标对象
        Object wrap = Plugin.wrap(target,this);

        //返回为当前target创建的动态代理
        return wrap;
    }

    /**
     * 将插件注册时的Property属性设置进来
     * @param properties
     */
    @Override
    public void setProperties(Properties properties) {
        System.out.println("插件配置的信息properties："+properties);
    }


}

测试：

    /**
     * mybatis运行原理以查询为例
     * @throws IOException
     */
    @Test
    public void testInterface() throws IOException {
        SqlSessionFactory sqlSessionFactory = getSqlSessionFactory();
        SqlSession sqlSession = sqlSessionFactory.openSession();
        try {
            EmployeeMapper employeeMapper = sqlSession.getMapper(EmployeeMapper.class);
            Employee employee = employeeMapper.getEmpByID(1);
            System.out.println(employee);

        }finally {
            sqlSession.close();
        }
    }

打印结果：SQL语句查询id是1的员工，我们使用拦截器设置了参数为5的员工，查询结果如下

MyPlugin...四大对象创建的时候被调用....plugin:Mybatis将要包装的对象org.apache.ibatis.executor.CachingExecutor@3f197a46
MySecondPlugin...plugin:org.apache.ibatis.executor.CachingExecutor@3f197a46
DEBUG 05-27 18:24:17,428 Cache Hit Ratio [com.ming.dao.EmployeeMapper]: 0.0  (LoggingCache.java:62) 
MyPlugin...四大对象创建的时候被调用....plugin:Mybatis将要包装的对象org.apache.ibatis.scripting.defaults.DefaultParameterHandler@5b239d7d
MySecondPlugin...plugin:org.apache.ibatis.scripting.defaults.DefaultParameterHandler@5b239d7d
MyPlugin...四大对象创建的时候被调用....plugin:Mybatis将要包装的对象org.apache.ibatis.executor.resultset.DefaultResultSetHandler@6d763516
MySecondPlugin...plugin:org.apache.ibatis.executor.resultset.DefaultResultSetHandler@6d763516
MyPlugin...四大对象创建的时候被调用....plugin:Mybatis将要包装的对象org.apache.ibatis.executor.statement.RoutingStatementHandler@37afeb11
MySecondPlugin...plugin:org.apache.ibatis.executor.statement.RoutingStatementHandler@37afeb11
DEBUG 05-27 18:24:17,432 ==>  Preparing: select id,last_name AS lastName,gender,email from tbl_employee WHERE id = ?   (BaseJdbcLogger.java:145) 
MySecondPlugin...intercept:public abstract void org.apache.ibatis.executor.statement.StatementHandler.parameterize(java.sql.Statement) throws java.sql.SQLException
MyPlugin....intercept:自定义插件拦截的目标方法public abstract void org.apache.ibatis.executor.statement.StatementHandler.parameterize(java.sql.Statement) throws java.sql.SQLException
拦截到的目标对象：org.apache.ibatis.executor.statement.RoutingStatementHandler@37afeb11
sql语句用的参数是：{id=1, param1=1}
DEBUG 05-27 18:24:17,446 ==> Parameters: 5(String)  (BaseJdbcLogger.java:145) 
DEBUG 05-27 18:24:17,455 <==      Total: 1  (BaseJdbcLogger.java:145) 
Employee{id=5, lastName='李四', email='88897@qq.com', gender='男', userList=null}
DEBUG 05-27 18:24:17,456 put added 0 on heap  (Segment.java:425)

三、扩展分页插件

1、PageHelper插件进行分页

PageHelper是MyBatis中非常方便的第三方分页插件

分页插件官方文档

使用步骤

1.引入依赖

		<dependency>
		    <groupId>com.github.pagehelper</groupId
		    <artifactId>pagehelper</artifactId>
		    <version>5.1.10</version>
			</dependency>
		<!-- pagehelper 依赖 -->
		<dependency>
		    <groupId>com.github.jsqlparser</groupId>
		    <artifactId>jsqlparser</artifactId>
		    <version>2.1</version>
		</dependency>
		
		<dependency>
	        <groupId>com.baomidou</groupId>
	        <artifactId>mybatis-plus-boot-starter</artifactId>
	    </dependency>

2、在MyBatis全局配置文件中配置分页插件

    <plugins>
        <plugin interceptor="com.ming.plugin.MyPlugin">
            <property name="username" value="root"/>
            <property name="password" value="123456"/>
        </plugin>
        <plugin interceptor="com.ming.plugin.MySecondPlugin">
        </plugin>
        <!-- com.github.pagehelper为PageHelper类所在包名 -->
        <plugin interceptor="com.github.pagehelper.PageInterceptor">
            <!-- 使用下面的方式配置参数，后面会有所有的参数介绍 -->
            <property name="param1" value="value1"/>
        </plugin>
    </plugins>

3、使用PageHelper提供的方法进行分页

	@Test
	public void test01() throws IOException {
		// 1、获取sqlSessionFactory对象
		SqlSessionFactory sqlSessionFactory = getSqlSessionFactory();
		// 2、获取sqlSession对象
		SqlSession openSession = sqlSessionFactory.openSession();
		try {
			EmployeeMapper mapper = openSession.getMapper(EmployeeMapper.class);
			Page<Object> page = PageHelper.startPage(5, 1);
			
			List<Employee> emps = mapper.getEmps();
			//传入要连续显示多少页
			PageInfo<Employee> info = new PageInfo<>(emps, 5);
			for (Employee employee : emps) {
				System.out.println(employee);
			}
			/*System.out.println("当前页码："+page.getPageNum());
			System.out.println("总记录数："+page.getTotal());
			System.out.println("每页的记录数："+page.getPageSize());
			System.out.println("总页码："+page.getPages());*/
			///xxx
			System.out.println("当前页码："+info.getPageNum());
			System.out.println("总记录数："+info.getTotal());
			System.out.println("每页的记录数："+info.getPageSize());
			System.out.println("总页码："+info.getPages());
			System.out.println("是否第一页："+info.isIsFirstPage());
			System.out.println("连续显示的页码：");
			int[] nums = info.getNavigatepageNums();
			for (int i = 0; i < nums.length; i++) {
				System.out.println(nums[i]);
			}
			
		} finally {
			openSession.close();
		}

	}

4、可以使用更强大的PageInfo封装返回结果

2、批量操作

第一种：ExecutorType.BATCH

    @Test
    public  void addBatchEmp() throws IOException {
        SqlSessionFactory sqlSessionFactory = getSqlSessionFactory();
        //可以执行批量操作的sqlsession
        SqlSession sqlSession = sqlSessionFactory.openSession(ExecutorType.BATCH);
        try {
            EmployeeMapper employeeMapper = sqlSession.getMapper(EmployeeMapper.class);
            for (int i = 0; i < 1000; i++) {
                Employee employee = new Employee();
                employee.setLastName(UUID.randomUUID().toString().substring(0,5));
                employee.setEmail("524933@qq.com");
                employee.setGender("男");
                employeeMapper.addEmps(employee);
            }
            sqlSession.commit();
        }finally {
            sqlSession.close();
        }
    }

第二种： 与Spring整合中，我们推荐，额外的配置一个可以专门用来执行批量操作的sqlSession
配置一个可以执行批量执行的sqlSession，并注入Sqlsession

    <!--3.spring整合mybatis-->
    <bean id="SqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
        <!--数据源-->
        <property name="dataSource" ref="dataSource"/>
        <!--指定mybatis全局文件的位置-->
        <property name="configLocation" value="classpath:mybatis/mybatis-config.xml"></property>
        <!--指定mybatis的mapper文件位置,如果mapper和xml在同一个目录可以不用配置-->
        <property name="mapperLocations" value="classpath:mapper/*.xml"/>
    </bean>
    <!--配置一个可以执行批量执行的sqlSession-->
    <bean id="sqlSessionTemplate" class="org.mybatis.spring.SqlSessionTemplate">
        <constructor-arg name="sqlSessionFactory" ref="SqlSessionFactory"/>
        <constructor-arg name="executorType" value="BATCH"/>
    </bean>

测试

    @Autowired
    SqlSession sqlSession;

    @Test
    public void mapperCrud() {
        //批量插入利用SqlSessionTemplate
        for (int i=0;i<1000;i++){
           String uuid= UUID.randomUUID().toString().substring(0,5)+i;
           EmpMapper empMapper = sqlSession.getMapper(EmpMapper.class);
           empMapper.insertSelective(new Emp(null,uuid,"m",uuid+"@qq.com",1));
        }

    }

需要用到批量操作的时候，我们可以注入配置的这个批量SqlSession。通过他获取到mapper映射器进行操作。

注意：
1、批量操作是在session.commit()以后才发送sql语句给数据库进行执行的

2、如果我们想让其提前执行，以方便后续可能的查询操作获取数据，我们可以使用sqlSession.flushStatements()方法，让其直接冲刷到数据库进行执行。

三、存储过程

一、创建
create procedure 存储过程名(参数模式 参数名 参数类型)
begin
存储过程体
end
注意：
1.参数模式：in、out、inout，其中in可以省略
2.存储过程体的每一条sql语句都需要用分号结尾

二、调用
call 存储过程名(实参列表)
举例：
调用in模式的参数：call sp1（‘值’）;
调用out模式的参数：set @name; call sp1(@name);select @name;
调用inout模式的参数：set @name=值; call sp1(@name); select @name;
三、查看
show create procedure 存储过程名;
四、删除
drop procedure 存储过程名;

在这里插入图片描述

	<!-- public void getPageByProcedure(); 
	1、使用select标签定义调用存储过程
	2、statementType="CALLABLE":表示要调用存储过程
	3、{call procedure_name(params)}
	-->
	<select id="getPageByProcedure" statementType="CALLABLE" databaseId="oracle">
		{call hello_test(
			#{start,mode=IN,jdbcType=INTEGER},
			#{end,mode=IN,jdbcType=INTEGER},
			#{count,mode=OUT,jdbcType=INTEGER},
			#{emps,mode=OUT,jdbcType=CURSOR,javaType=ResultSet,resultMap=PageEmp}
		)}
	</select>
	<resultMap type="com.atguigu.mybatis.bean.Employee" id="PageEmp">
		<id column="EMPLOYEE_ID" property="id"/>
		<result column="LAST_NAME" property="lastName"/>
		<result column="EMAIL" property="email"/>
	</resultMap>	


/**
 * 封装oracle分页
 */
public class Page {

    private Integer start;
    private Integer end;
    private List<Employee> employeeList;
}

	/**
	 * oracle分页：
	 * 		借助rownum：行号；子查询；
	 * 存储过程包装分页逻辑
	 * @throws IOException 
	 */
	@Test
	public void testProcedure() throws IOException{
		SqlSessionFactory sqlSessionFactory = getSqlSessionFactory();
		SqlSession openSession = sqlSessionFactory.openSession();
		try{
			EmployeeMapper mapper = openSession.getMapper(EmployeeMapper.class);
			OraclePage page = new OraclePage();
			page.setStart(1);
			page.setEnd(5);
			mapper.getPageByProcedure(page);
			
			System.out.println("总记录数："+page.getCount());
			System.out.println("查出的数据："+page.getEmps().size());
			System.out.println("查出的数据："+page.getEmps());
		}finally{
			openSession.close();
		}
		
	}

mysql_procedure:

create procedure mb_emps(in p_id int)

begin
        select * from tbl_employee WHERE id = p_id;
end;


show create procedure mb_emps;

    <!--  mysql储存过程调用
    1、使用select标签定义调用存储过程
    2、statementType="CALLABLE":表示要调用存储过程
    3、{call procedure_name(params)}-->
   <!-- public List<Employee> getEmps(Integer id);-->
    <select id="getEmps" statementType="CALLABLE" resultMap="procedureEmp">
       {CALL mb_emps(#{userId,mode=IN,jdbcType=INTEGER})}
    </select>
    <resultMap id="procedureEmp" type="com.ming.po.Employee">
        <id property="id" column="id"></id>
        <result property="lastName" column="last_name" jdbcType="VARCHAR"/>
        <result property="email" column="email" jdbcType="VARCHAR"/>
        <result property="gender" column="gender" jdbcType="VARCHAR"/>
    </resultMap>

    @Test
    public void procedureTest() throws IOException {
        SqlSessionFactory sqlSessionFactory = getSqlSessionFactory();
        SqlSession sqlSession = sqlSessionFactory.openSession();
        try {
            EmployeeMapper employeeMapper = sqlSession.getMapper(EmployeeMapper.class);
            List<Employee> emps = employeeMapper.getEmps(1);
            System.out.println(emps);
        }finally {
            sqlSession.close();
        }
    }

四、自定义类型处理器

我们可以通过自定义TypeHandler的形式来在设置参数或者取出结果集的时候自定义参数封装策略。

步骤：
1、实现TypeHandler接口或者继承BaseTypeHandler

2、使用@MappedTypes定义处理的Java类型、使用@MappedJdbcTypes定义jdbcType类型

3、在自定义结果集标签或者参数处理的时候声明使用自定义TypeHandler进行处理或者在全局配置TypeHandler要处理的javaType

自定义类型处理器

package com.ming.typehandler;

import com.ming.po.EmpStatus;
import org.apache.ibatis.type.JdbcType;
import org.apache.ibatis.type.TypeHandler;

import java.sql.CallableStatement;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;

/**
 * 自定义类型处理器
 *
 * 实现TypeHandler或者继承BaseTypeHandler
 *
 */
public class MyTypeHandler implements TypeHandler<EmpStatus> {
     // 定义当前数据如何保存到数据库中
    @Override
    public void setParameter(PreparedStatement preparedStatement, int i, EmpStatus empStatus, JdbcType jdbcType) throws SQLException {
        System.out.println("数据库要保存的状态码："+empStatus.getCode());
        preparedStatement.setString(i,empStatus.getCode().toString());
    }

    @Override
    public EmpStatus getResult(ResultSet resultSet, String s) throws SQLException {
        //根据从数据库中拿到枚举状态码返回枚举对象
        int code = resultSet.getInt(s);
        System.out.println("从数据库中获取的状态码："+code);
        return EmpStatus.getEmpByCode(code);
    }

    @Override
    public EmpStatus getResult(ResultSet resultSet, int i) throws SQLException {
        //根据从数据库中拿到枚举状态码返回枚举对象
        int code = resultSet.getInt(i);
        System.out.println("从数据库中获取的状态码："+code);
        return EmpStatus.getEmpByCode(code);
    }

    @Override
    public EmpStatus getResult(CallableStatement callableStatement, int i) throws SQLException {
        //根据从数据库中拿到枚举状态码返回枚举对象
        int code = callableStatement.getInt(i);
        System.out.println("从数据库中获取的状态码："+code);
        return EmpStatus.getEmpByCode(code);
    }
}

mybatis-config.xml配置类型处理器

    <!--类型处理器-->
    <typeHandlers>
        <!--1、配置自定义的类型处理器-->
        <typeHandler handler="com.ming.typehandler.MyTypeHandler" javaType="com.ming.po.EmpStatus"/>
        <!--<typeHandler handler="org.apache.ibatis.type.EnumOrdinalTypeHandler" javaType="com.ming.po.EmpStatus"/>-->
        <!--2、也可以在处理某个字段的时候告诉mybatis用什么类型处理器
        保存：在取值的时候设置类型处理器
        #{empStatus,TypeHandler=TypeHandler全限定类名(EnumOrdinalTypeHandler)}
        查询： <result property="empStatus" column="empStatus" typeHandler=""/>
        注意：如果在参数位置修改TypeHandler，应该保证保存数据和查询数据用的TypeHandler是一样的
        -->
    </typeHandlers>

package com.ming.po;

/**
 * 数据库保存状态码
 */
public enum EmpStatus {

    LOGIN(100,"用户登录"),LOGOUT(200,"用户登出"),REMOVE(300,"用户不存在");

    private EmpStatus(Integer code, String msg) {
        this.code = code;
        this.msg = msg;
    }

    private Integer code;
    private String msg;

    public Integer getCode() {
        return code;
    }

    public String getMsg() {
        return msg;
    }

    //按照状态码返回枚举对象
    public static EmpStatus getEmpByCode(Integer code){
        switch (code){
            case 100:
                return LOGIN;
            case 200:
                return LOGOUT;
            case 300:
                return REMOVE;
            default:
                return LOGOUT;
        }
    }
    
}
明了LM
关注
  • 0
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
专栏目录
MyBatis插件
12-19
MyBatis_Generator应用于MyEclipse中的MyBatis插件进行开发
Mybatis插件
qq_40977467的博客
05-17 2534
Mybatis插件 插件简介 一般情况下，开源框架都会提供插件或其他形式的拓展点，供开发者自行拓展。这样的好处是显而易见的，一是增加了框架的灵活性。二是开发者可以结合实际需求，对框架进行拓展，使其能够更好的工作。以MyBatis为例，我们可基于MyBatis插件机制实现分页、分表，监控等功能。由于插件和业务 无关，业务也无法感知插件的存在。因此可以无感植入插件，在无形中增强功能 Mybatis插件介绍 Mybatis作为一个应用广泛的优秀的ORM开源框架，这个框架具有强大的灵活性，在四大组件(Executo
MyBatis插件深度解析：功能、原理、使用、应用场景与最佳实践
码到三十五
02-22 1072
MyBatis插件机制为开发者提供了一个强大而灵活的扩展工具，通过深入了解其功能、原理、使用步骤、应用场景和最佳实践，我们可以更好地利用这一工具来满足特定的业务需求，提升开发效率和系统性能。希望本篇文章能为对MyBatis插件感兴趣的开发者提供有价值的技术分享和参考。
深入浅出MyBatis：MyBatis插件及开发过程
weixin_33851429的博客
03-30 98
本篇文章是「深入浅出MyBatis：技术原理与实践」书籍的总结笔记。 上一篇介绍了 MyBatis解析和运行原理 ，包括SqlSessionFactory的构建和SqlSession的执行过程，其中，SqlSession包含四大对象，可以在四大对象调度的时候插入自定义的代码，以满足特殊的需求，这便是MyBatis提供的插件技术。 系列索引： JDBC和MyBatis介绍 MyBatis的所有...
MyBatis的插件
JDS_DIJ的博客
03-09 1673
插件其实就是通过jdk动态代理将目标对象进行包装 本文章是跟着尚硅谷的视频记录的,详情请观看视频 1. 实现Interceptor接口 MyBatis提供了一个Interceptor接口;org.apache.ibatis.plugin 自制插件需要实现MyBatis提供的这个接口 2. 实现接口的方法 interceptor: 拦截到的目标方法;在这里控制目标方法执不执行,也可以在目标方法执行前后做一些我们自己的设置 plugin: 包装目标对象;即为目标对象创建代理对象 setPrope.
mybatis 插件
江城宴的博客
08-07 372
Mybatis插件又称拦截器，本篇文章中出现的拦截器都表示插件。 Mybatis采用责任链模式，通过动态代理组织多个插件（拦截器），通过这些插件可以改变Mybatis的默认行为（诸如SQL重写之类的），由于插件会深入到Mybatis的核心，因此在编写自己的插件前最好了解下它的原理，以便写出安全高效的插件。 MyBatis 允许你在已映射语句执行过程中的某一点进行拦截调用。默认情况下，MyBat...
毕业设计：springmvc+mybatis企业人事管理系统（源码 + 数据库 + 说明文档）
最新发布
04-27
毕业设计：springmvc+mybatis企业人事管理系统（源码 + 数据库 + 说明文档） 第二章 系统分析 6 2.1可行性分析 6 2.2 系统的安全技术 7 2.4设计的基本思想 7 2.4性能需求 8 2.4.1系统的安全性 8 2.4.2数据的完整性 8...
基于springboot社区疫情防控管理系统代码-java - springboot - mybatis-代码
01-11
基于springboot社区疫情防控管理系统代码-java - springboot - mybatis-代码-源码-社区疫情防控管理系统 1、技术栈：微信小程序，springboot，uniapp，vue，ajax，maven，mysql，MyBatisPlus 2、系统的实现 用户...
MyBatis入门视频课程
06-13
2. 第一个MyBatis程序 3. 基于接口的实现 4. MyBatisUtil工具类 5. CRUD操作 6. 手动映射 7.多参数查询 8.动态SQL 9.多表关系映射 10.代码生成器mybatis-generator 11.分页插件PageHelper 教学全程采用...
基于ssm农业信息智能化种植系统代码 - java - ssm- spring - springmvc -mybatis-代码
01-11
基于ssm农业信息智能化种植系统代码 | java | ssm| spring | springmvc | mybatis | 网站 | 代码 1、技术栈：微信小程序，springboot，uniapp，vue，ajax，maven，mysql，MyBatisPlus 2、系统的实现 用户信息 图片...
超级好用的mybatis 插件
05-09
超级好用的mybatis 插件 ，可以很方便的实现mapper 和配置文件之间的切换，可以提示错误信息，代码生成等
mybatis插件
12-02
mybatis的插件!适用于idea2017和2018.1.5.喜欢拿走！！
MyBatis Generator插件
02-25
eclipse插件，MyBatis Generator。eclipse插件，MyBatis Generator。eclipse插件，MyBatis Generator。eclipse插件，MyBatis Generator。
mybatis中的插件
多看多听多总结
11-07 333
1、Interceptor 2、插件配置解析 配置文件中解析plugins结点，在子结点中获取interceptor属性及子结点的属性结点。添加到配置文件中的InterceptorChain中 private void pluginElement(XNode parent) throws Exception { if (parent != null) { for (XNode child : parent.getChildren()) { String i..
MyBatis_MyBatis之插件
u013185175的博客
02-09 427
1.引入
mybatis-插件
sashaSloan的博客
03-12 513
mybatis-插件 （新手笔记，参考自尚硅谷） 尚硅谷mybatis实战 缓存mybatis-插件1、插件原理 1、插件原理
Cannot resolve org.mybatis:mybatis-spring:3.5.3 Cannot resolve org.mybatis.spring.boot:mybatis-spring-boot-starter:unknown
05-05
这个错误提示通常是由于Maven中央仓库中没有找到所需的包或版本号错误导致的。可以尝试更新Maven本地仓库或检查pom.xml中是否有正确的依赖项。 对于第一个错误提示，可以尝试在pom.xml文件中添加以下依赖项： ``` <dependency> <groupId>org.mybatis</groupId> <artifactId>mybatis-spring</artifactId> <version>3.5.3</version> </dependency> ``` 对于第二个错误提示，可以尝试在pom.xml文件中添加以下依赖项： ``` <dependency> <groupId>org.mybatis.spring.boot</groupId> <artifactId>mybatis-spring-boot-starter</artifactId> <version>2.1.2</version> </dependency> ``` 请注意，版本号可能需要根据您的项目进行调整。如果仍然无法解决问题，请尝试清除Maven本地仓库并重新构建项目。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值