Mybatis反射实现装载Mapper

柔光的暖阳◎ 2022-12-27 08:21 115阅读 0赞

## Mapper类 ##

package cn.lsh.kafka.db.dao;
    
    import cn.lsh.kafka.db.entity.OffsetEntity;
    import org.apache.ibatis.annotations.*;
    
    import java.util.List;
    
    /** * kafka偏移量(Offset)表数据库访问层 * * @author makejava * @since 2020-12-08 14:33:12 */
    public interface OffsetMapper { 
    
    	/** * 通过ID查询单条数据 * * @param id 主键 * @return 实例对象 */
    	@Select("SELECT * from offset where id = #{id}")
    	OffsetEntity queryById(Integer id);
    
    	@Select("SELECT * from offset where group_id = #{groupId} and topic = #{topic} and partition_id = #{partitionId}")
    	OffsetEntity queryByCond(@Param("groupId") String groupId, @Param("topic") String topic, @Param("partitionId") int partitionId);
    
    	/** * 查询指定行数据 * * @param offset 查询起始位置 * @param limit 查询条数 * @return 对象列表 */
    	@Select("SELECT * from offset limit #{limit} offset #{offset}")
    	List<OffsetEntity> queryAllByLimit(@Param("offset") int offset, @Param("limit") int limit);
    
    	/** * 通过实体作为筛选条件查询 * * @param offset 实例对象 * @return 对象列表 */
    	List<OffsetEntity> queryAll(OffsetEntity offset);
    
    	/** * 新增数据 * * @param offset 实例对象 * @return 影响行数 */
    	@Insert("INSERT INTO offset(group_id,topic,partition_id,value,create_date,update_date) VALUES(#{groupId},#{topic},#{partitionId},#{value},#{createDate},#{updateDate})")
    	int insert(OffsetEntity offset);
    
    	/** * 修改数据 * * @param offset 实例对象 * @return 影响行数 */
    	@Update("UPDATE offset SET value = #{value}, update_date=#{updateDate} where id = #{id}")
    	int update(OffsetEntity offset);
    
    	/** * 通过主键删除数据 * * @param id 主键 * @return 影响行数 */
    	@Delete("DELETE FROM offset where id = #{id}")
    	int deleteById(Integer id);
    
    }

mybatis的Mapper类支持注解的方式映射sql语句，省去了mapper的xml映射文件。

## 基类Service ##

package cn.lsh.kafka.db.service;
    
    import org.apache.ibatis.session.SqlSession;
    
    public abstract class BaseService<T> { 
    
    	protected SqlSession sqlSession;
    	/** 泛型T为实体的Mapper类 */
    	protected T mapper;
    
    	public BaseService(SqlSession sqlSession) { 
    		//为service装载sqlSession
    		this.sqlSession = sqlSession;
    	}
    
    	protected void commit() { 
    		this.sqlSession.commit();
    	}
    
    	protected void close() { 
    		//private不能被子类继承，protect可以被子类继承，但是不能被反射出来
    		this.close();
    	}
    
    	public void setMapper(Class<T> t) { 
    		try { 
    			this.mapper = this.sqlSession.getMapper(t);
    		} catch (Exception e) { 
    			this.sqlSession.getConfiguration().addMapper(t);
    			this.mapper = sqlSession.getMapper(t);
    		}
    	}
    }

所有Service都继承这个抽象类，这个类主要关注以下三个地方：

1.  泛型：泛型必须申明为实体对应Mapper映射类；
2.  sqlSession：该类维持一个sqlSession，通过构造器加载，供其继承类使用；
3.  setMapper：实现了一个setMapper方法，该方法自动为service注册Mapper到sqlSession。

## 业务Service接口 ##

public interface OffsetService { 
    
    
        /** * 通过ID查询单条数据 * * @param id 主键 * @return 实例对象 */
        OffsetEntity queryById(Integer id);
    
        OffsetEntity queryByCond(String groupId, String topic, int partitionId);
    
        /** * 查询多条数据 * * @param offset 查询起始位置 * @param limit 查询条数 * @return 对象列表 */
        List<OffsetEntity> queryAllByLimit(int offset, int limit);
    
        /** * 新增数据 * * @param offset 实例对象 * @return 实例对象 */
        OffsetEntity insert(OffsetEntity offset);
    
        /** * 修改数据 * * @param offset 实例对象 * @return 实例对象 */
        OffsetEntity update(OffsetEntity offset);
    
        void update(int id, long value);
    
        /** * 通过主键删除数据 * * @param id 主键 * @return 是否成功 */
        boolean deleteById(Integer id);
    
    }

定义业务处理接口方法，没有其他特殊逻辑。

## 业务接口实现类 ##

public class OffsetServiceImpl extends BaseService<OffsetMapper> implements OffsetService { 
    
        // private OffsetMapper offsetMapper;
    
        public OffsetServiceImpl(SqlSession sqlSession) { 
            super(sqlSession);
        }
    
        /*public OffsetServiceImpl() { TransactionFactory factory = new JdbcTransactionFactory(); DataSource dataSource = new PooledDataSource("com.mysql.jdbc.Driver", "jdbc:mysql://localhost:3306/bigdata", "root", "admin"); Environment environment = new Environment("ID", factory, dataSource); Configuration conf = new Configuration(environment); conf.addMapper(OffsetMapper.class); SqlSessionFactory sessionFactory = new SqlSessionFactoryBuilder().build(conf); this.sqlSession = sessionFactory.openSession(); offsetMapper = sqlSession.getMapper(OffsetMapper.class); }*/
    
        /** * 通过ID查询单条数据 * * @param id 主键 * @return 实例对象 */
        @Override
        public OffsetEntity queryById(Integer id) { 
            return this.mapper.queryById(id);
        }
    
        @Override
        public OffsetEntity queryByCond(String groupId, String topic, int partitionId) { 
            return this.mapper.queryByCond(groupId, topic, partitionId);
        }
    
        /** * 查询多条数据 * * @param offset 查询起始位置 * @param limit 查询条数 * @return 对象列表 */
        @Override
        public List<OffsetEntity> queryAllByLimit(int offset, int limit) { 
            return this.mapper.queryAllByLimit(offset, limit);
        }
    
        /** * 新增数据 * * @param offset 实例对象 * @return 实例对象 */
        @Override
        public OffsetEntity insert(OffsetEntity offset) { 
            this.mapper.insert(offset);
            return offset;
        }
    
        /** * 修改数据 * * @param offset 实例对象 * @return 实例对象 */
        @Override
        public OffsetEntity update(OffsetEntity offset) { 
            this.mapper.update(offset);
            return this.queryById(offset.getId());
        }
    
        @Override
        public void update(int id, long value) { 
            OffsetEntity offset = new OffsetEntity();
            offset.setId(id);
            offset.setValue(value);
            offset.setUpdateDate(new Date());
            this.mapper.update(offset);
        }
    
        /** * 通过主键删除数据 * * @param id 主键 * @return 是否成功 */
        @Override
        public boolean deleteById(Integer id) { 
            boolean flag = this.mapper.deleteById(id) > 0;
            return flag;
        }
    
        public static void main(String[] args) { 
            // OffsetService service = new OffsetServiceImpl();
            OffsetService service = ServiceFactory.buildService(OffsetService.class);
            OffsetEntity entity = new OffsetEntity();
            entity.setGroupId("11111");
            entity.setPartitionId(1);
            entity.setTopic("adad");
            entity.setValue(10L);
            Date now = new Date();
            entity.setCreateDate(now);
            entity.setUpdateDate(now);
            service.insert(entity);
            OffsetEntity offsetEntity = service.queryById(5);
            System.out.println(offsetEntity);
            ServiceFactory.commitAndClose();
        }
    }

需要继承BaseService，并继承其构造器实现。其他就都是业务接口实现了。

## Service工厂类 ##

public class ServiceFactory { 
    
    	private static SqlSession sqlSession;
    
    	//私有构造器
    	private ServiceFactory() { }
    
    	public static SqlSession createSession() { 
    		//维持一个单例sqlSession
    		if (sqlSession == null) { 
    			TransactionFactory factory = new JdbcTransactionFactory();
    			DataSource dataSource = new PooledDataSource("com.mysql.jdbc.Driver", "jdbc:mysql://localhost:3306/bigdata", "root", "admin");
    			Environment environment = new Environment("ID", factory, dataSource);
    			Configuration conf = new Configuration(environment);
    			SqlSessionFactory sessionFactory = new SqlSessionFactoryBuilder().build(conf);
    			sqlSession = sessionFactory.openSession();
    		}
    		return sqlSession;
    	}
    
    	public static void commit() { 
    		if (sqlSession != null) { 
    			sqlSession.commit();
    		}
    	}
    
    	public static void close() { 
    		if (sqlSession != null) { 
    			sqlSession.close();
    		}
    	}
    
    	public static void commitAndClose() { 
    		commit();
    		close();
    	}
    
    	public static <T> T buildService(Class<T> clazz) { 
    		try { 
    			String name = clazz.getName();
    			String implName = name.replaceAll(clazz.getSimpleName(), "impl.") + clazz.getSimpleName() + "Impl";
    			//反射加载service的实现类
    			Class<?> implClass = clazz.getClassLoader().loadClass(implName);
    			Constructor<?> constructor = implClass.getConstructor(SqlSession.class);
    			Object o = constructor.newInstance(createSession());
    			String mapperName = name.replaceAll(clazz.getSimpleName(), clazz.getSimpleName().replaceAll("Service", "Mapper")).replaceAll("service", "dao");
    			//反射加载Mapper类
    			Class<?> mapperClass = clazz.getClassLoader().loadClass(mapperName);
    			//反射调用BaseService的setMapper向SQLSession中注册Mapper
    			Method setMapper = implClass.getMethod("setMapper", Class.class);
    			setMapper.invoke(o, mapperClass);
    			return (T) o;
    		} catch (NoSuchMethodException | InstantiationException | IllegalAccessException | InvocationTargetException | ClassNotFoundException e) { 
    			throw new RuntimeException("反射Service异常--" + e);
    		}
    	}
    }

通过ServiceFactory反射Service实现类实例。该工厂类采用单例模式，私有化构造器，维护一个SQLSession。主要有两个方法：

*  createSession：这个方法连接数据库，构建sqlSession会话对象；
 *  buildService：这个方法通过反射构建Service实现类，主要有以下几步  
    1、接收一个Service的class对象  
    2、通过class拼装器实现类的全路径名  
    3、反射获得service的实现类对象，同时会为其装载SQLSession  
    4、反射加载Mapper类  
    5、反射调用BaseService的setMapper向SQLSession中注册  
    Mapper  
    6、返回加载好的Service实现类对象

## 存在问题 ##

service实现类需要继承BaseService，导致无法继承其他类，还需后续研究改进。