探究MyBatis插件原理以及自定义插件实现

public ParameterHandler newParameterHandler(MappedStatement mappedStatement,
Object object, BoundSql sql, InterceptorChain interceptorChain){
    ParameterHandler parameterHandler =
    mappedStatement.getLang().createParameterHandler(mappedStatement,object,sql);
    parameterHandler = (ParameterHandler)interceptorChain.pluginAll(parameterHandler);
    return parameterHandler;
}
public Object pluginAll(Object target) {
    for (Interceptor interceptor : interceptors) {
        target = interceptor.plugin(target);
    }
    return target;
}

@Intercepts({
    @Signature(
    type = Executor.class,
    method = "query",
    args={MappedStatement.class,Object.class,RowBounds.class,ResultHandler.class}
    )
})
public class ExeunplePlugin implements Interceptor {
    //省略逻辑
}

<plugins>
  <plugin interceptor="com.zjq.plugin.ExamplePlugin"></plugin>
</plugins>

@Intercepts({//注意看这个⼤花括号，也就这说这⾥可以定义多个@Signature对多个地⽅拦截，都⽤这个拦截器
    @Signature(type = StatementHandler.class , //这是指拦截哪个接⼝
    method = "prepare", //这个接⼝内的哪个⽅法名，不要拼错了
    args = { Connection.class, Integer .class}),  //这是拦截的⽅法的⼊参，按顺序写到这，不要多也不要少，如果⽅法重载，可是要通过⽅法名和⼊参来确定唯⼀的
})
public class MyPlugin implements Interceptor {
    // //这⾥是每次执⾏操作的时候，都会进⾏这个拦截器的⽅法内
    @Override
    public Object intercept(Invocation invocation) throws Throwable {
        //增强逻辑
        System.out.println("对⽅法进⾏了增强....");
        return invocation.proceed(); //执⾏原⽅法
    }
    /**
    * //主要是为了把这个拦截器⽣成⼀个代理放到拦截器链中
    * ^Description包装⽬标对象 为⽬标对象创建代理对象
    * @Param target为要拦截的对象
    * @Return代理对象
    */
    @Override
    public Object plugin(Object target) {
        System.out.println("将要包装的⽬标对象："+target);
        return Plugin.wrap(target,this);
    }
    /**获取配置⽂件的属性**/
    //插件初始化的时候调⽤，也只调⽤⼀次，插件配置的属性从这⾥设置进来
    @Override
    public void setProperties(Properties properties) {
        System.out.println("插件配置的初始化参数："+properties );
    }
}

<mapper namespace="com.zjq.mapper.UserMapper">
    <!--sql语句抽取-->
    <sql id="selectUser">
      select * from user
    </sql>
    <select id="findByCondition" parameterType="user" resultType="user">
        <include refid="selectUser"></include>
        <where>
            <if test="id!=0">
                and id=#{id}
            </if>
            <if test="username!=null and username!=''">
                and username=#{username}
            </if>
            <if test="password!=null and password!=''">
                and password=#{password}
            </if>
        </where>
    </select>
  </mapper>

public class PluginTest {
    @Test
    public void test() throws IOException {
        InputStream resourceAsStream =
        Resources.getResourceAsStream("sqlMapConfig.xml");
        SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(resourceAsStream);
        SqlSession sqlSession = sqlSessionFactory.openSession();
        UserMapper userMapper = sqlSession.getMapper(UserMapper.class);
        User condition = new User();
        //condition.setId(1);
        condition.setUsername("zjq");
        List<User> byPaging = userMapper.findByCondition(condition);
        for (User user : byPaging) {
            System.out.println(user);
        }
    }
}

// -Plugin
public Object invoke(Object proxy, Method method, Object[] args) throws
Throwable {
    try {
    /*
    *获取被拦截⽅法列表，⽐如：
    * signatureMap.get(Executor.class), 可能返回 [query, update,
    commit]
    */
    Set<Method> methods = signatureMap.get(method.getDeclaringClass());
    //检测⽅法列表是否包含被拦截的⽅法
    if (methods != null && methods.contains(method)) {
        //执⾏插件逻辑
        return interceptor.intercept(new Invocation(target, method,
        args));
        //执⾏被拦截的⽅法
        return method.invoke(target, args);
        } catch(Exception e){
    }
}

public class Invocation {
    private final Object target;
    private final Method method;
    private final Object[] args;
    public Invocation(Object targetf Method method, Object[] args) {
    this.target = target;
    this.method = method;
    //省略部分代码
    public Object proceed() throws InvocationTargetException,
    IllegalAccessException { //调⽤被拦截的⽅法

<dependency>
  <groupId>com.github.pagehelper</groupId>
  <artifactId>pagehelper</artifactId>
  <version>3.7.5</version>
</dependency>
<dependency>
  <groupId>com.github.jsqlparser</groupId>
  <artifactId>jsqlparser</artifactId>
  <version>0.9.1</version>
</dependency>

<!--注意：分⻚助⼿的插件 配置在通⽤馆mapper之前*-->*
<plugin interceptor="com.github.pagehelper.PageHelper">
  <!—指定⽅⾔ —>
  <property name="dialect" value="mysql"/>
</plugin>

@Test
public void testPageHelper() {
    //设置分⻚参数
    PageHelper.startPage(1, 2);
    User condition = new User();
    //condition.setId(1);
    condition.setUsername("zjq");
    List<User> select = userMapper.findByCondition(condition);
    for (User user : select) {
        System.out.println(user);
    }
}

//其他分⻚的数据
PageInfo<User> pageInfo = new PageInfo<User>(select);
System.out.println("总条数："+pageInfo.getTotal());
System.out.println("总⻚数："+pageInfo. getPages ());
System.out.println("当前⻚："+pageInfo. getPageNum());
System.out.println("每⻚显示⻓度："+pageInfo.getPageSize());
System.out.println("是否第⼀⻚："+pageInfo.isIsFirstPage());
System.out.println("是否最后⼀⻚："+pageInfo.isIsLastPage());

<dependency>
  <groupId>tk.mybatis</groupId>
  <artifactId>mapper</artifactId>
  <version>3.1.2</version>
</dependency>

<plugins>
  <!--分⻚插件：如果有分⻚插件，要排在通⽤mapper之前-->
  <plugin interceptor="com.github.pagehelper.PageHelper">
    <property name="dialect" value="mysql"/>
  </plugin>
  <plugin interceptor="tk.mybatis.mapper.mapperhelper.MapperInterceptor">
    <!-- 通⽤Mapper接⼝，多个通⽤接⼝⽤逗号隔开 -->
    <property name="mappers" value="tk.mybatis.mapper.common.Mapper"/>
  </plugin>
</plugins>

@Table(name = "t_user")
public class User {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Integer id;
    private String username;
}

import com.zjq.domain.User;
import tk.mybatis.mapper.common.Mapper;
public interface UserMapper extends Mapper<User> {
}

@Test
public void test1() throws IOException {
    Inputstream resourceAsStream =
    Resources.getResourceAsStream("sqlMapConfig.xml");
    SqlSessionFactory build = new
    SqlSessionFactoryBuilder().build(resourceAsStream);
    SqlSession sqlSession = build.openSession();
    UserMapper userMapper = sqlSession.getMapper(UserMapper.class);
    User user = new User();
    user.setId(4);
    //(1)mapper基础接⼝
    //select 接⼝
    //根据实体中的属性进⾏查询，只能有一个返回值
    User user1 = userMapper.selectOne(user); 
    //查询全部结果
    List<User> users = userMapper.select(null); 
    //根据主键字段进⾏查询，⽅法参数必须包含完整的主键属性，查询条件使⽤等号
    userMapper.selectByPrimaryKey(1); 
    //根据实体中的属性查询总数，查询条件使⽤等号
    userMapper.selectCount(user); 
    // insert 接⼝
    //保存⼀个实体，null值也会保存，不会使⽤数据库默认值
    int insert = userMapper.insert(user);
    //保存实体，null的属性不会保存，会使⽤数据库默认值
    int i = userMapper.insertSelective(user); 
    // update 接⼝
    //根据主键更新实体全部字段，null值会被更新
    int i1 = userMapper.updateByPrimaryKey(user);
    // delete 接⼝
    //根据实体属性作为条件进⾏删除，查询条件使⽤等号
    int delete = userMapper.delete(user);
    //根据主键字段进⾏删除，⽅法参数必须包含完整的主键属性
    userMapper.deleteByPrimaryKey(1); 
    //(2)example⽅法
    Example example = new Example(User.class);
    example.createCriteria().andEqualTo("id", 1);
    example.createCriteria().andLike("val", "1");
    //⾃定义查询
    List<User> users1 = userMapper.selectByExample(example);
}