代理模式以及mybatis中的简单实现

最新推荐文章于 2024-09-06 19:47:28 发布
最新推荐文章于 2024-09-06 19:47:28 发布
阅读量748 收藏 1
点赞数 2
文章标签： 设计模式
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weiqiang2/article/details/86735932
版权

文章目录

代理模式

1.1 代理模式的作用

​ 将开发中的主要业务和次要业务进行松耦合的组装.让开发人员只关心功能里面的主要业务,不再关心次要业务.降低了对现有代码维护的难度.

1.2 代理模式的本质

​ 监控状态.监控行为特征

<input type="button" onclick="处理函数">

1.3 代理模式的分类

​ 1. 静态代理

​ 2. 动态代理(JDK动态代理,cglib动态代理)

​ 案例: 饭前便后要洗手

​ 主要业务: 吃饭,上厕所

​ 次要业务: 洗手

1.4 JDK动态代理模式实现(基于接口的动态代理)

​ (1) 接口角色:定义需要监听的行为(只要吃饭就监控,但是吃饭的行为细节可以不一样)

package com.wq.proxy;

public interface BaseService {

    public String eat();
    public String ec();

}

​ (2) 接口的实现类(需要知道去监听的具体的某个人)

package com.wq.proxy.impl;

import com.wq.proxy.BaseService;

/**
 * @ClassName ServiceImpl
 * @Description 实现类
 * @Author wq
 * @Date 2019/1/31 16:26
 * @Version 1.0.0
 */
public class ServiceImpl implements BaseService {

    /**
     * 只关心主要业务
     */
    public String eat() {
        System.out.println("吃饭");
        return "eat";
    }

    /**
     * 只关心主要业务
     */
    public String ec() {
        System.out.println("上厕所");
        return "ec";
    }

}

​ (3) 通知类: 对次要业务进行具体的实现; 通知JVM,当前被拦截的主要的业务方法和被声明的次要方法应该如何绑定.

package com.wq.proxy.advice;

import com.wq.proxy.BaseService;

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;

/**
 * @ClassName Invocation
 * @Description 通知:告诉主业务在做主业务之前需要怎么做
 * @Author wq
 * @Date 2019/1/31 16:30
 * @Version 1.0.0
 */
public class Invocation implements InvocationHandler {

    /**
     * 监控的行为抽象
     */
    private BaseService baseService;

    /**
     * 创建通知的时候需要指定监控谁
     * @param obj
     */
    public Invocation (BaseService obj){
        this.baseService = obj;
    }


    /**
     * 在被监控的行为将要执行的时候,拦截住这个方法.
     * 被监控方法的信息会被作为参数传递进来
     *      与主业务的方法绑定执行
     * @param proxy  代理对象(执行主业务方法对象的代理对象)
     * @param method 被拦截的方法
     * @param args   运行时所有的实参封装在数组中
     * @return
     * @throws Throwable
     */
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        //确认当前呗拦截的方法
        String methodName = method.getName();
        //根据被拦截的行为的不同决定如何将次要业务和主要业务绑定执行
        Object invoke = null;
        if ("eat".equals(methodName)){
            //先洗手后吃饭
            wash();
            invoke = method.invoke(this.baseService, args);
            invoke = "eat";
        }

        if ("ec".equals(methodName)){
            //先上厕所后洗手
            invoke = method.invoke(this.baseService, args);
            wash();
            invoke = "ec";
        }
        return invoke;
    }

    /**
     * 次要业务
     */
    public void wash(){
        System.out.println("洗手");
    }

}

​ (4) 监控对象(代理对象):创建是由JVM提供:被监控的是谁,监控的方法

package com.wq.proxy.factory;

import com.wq.proxy.BaseService;
import com.wq.proxy.advice.Invocation;
import com.wq.proxy.impl.ServiceImpl;

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Proxy;

/**
 * @ClassName ProxyFactory
 * @Description 代理对象创建工厂
 * @Author wq
 * @Date 2019/1/31 16:52
 * @Version 1.0.0
 */
public class ProxyFactory {

    /**
     * 代理对象的类型应该由被监控的类型决定
     * type:被监控对象的类型
     */
    public static BaseService newInstatnce(Class type) throws IllegalAccessException, InstantiationException {
        //创建一个被监控的实例对象
        BaseService o = (BaseService) type.newInstance();
        InvocationHandler invocation = new Invocation(o);
        //向JVM申请负责监控BaseService的代理对象
        //loader:被监控对象类文件真实地址
        BaseService proxyInstance = (BaseService) 					Proxy.newProxyInstance(o.getClass().getClassLoader(), o.getClass().getInterfaces(), invocation);
        return proxyInstance;
    }
}

1.5 Mybatis中的代理模式探究

1.1 JDBC的开发步骤

  1. 加载驱动

  2. 建立连接通道

  3. 建立PrepareStatement

  4. 输送SQL命令道数据库中执行,并带回运行结果

  5. 销毁连接通道,PreparedStatement

1.2 JDBC中的主要业务与次要业务解析

​ 次要业务:

​ 加载驱动

​ 建立连接通道

​ 建立PreparedStatement

​ 销毁连接通道和PreparedStatement

​ 主要业务:

​ 输送SQL命令到数据库执行并但会运行结果

1.3 简单实现

​ 接口代码

package com.wq.proxy2.service;

import java.sql.SQLException;

public interface SqlSession {

    int save(String sql) throws SQLException;
}

​ 实现类

package com.wq.proxy2.service.impl;

import com.wq.proxy2.service.SqlSession;

import java.sql.PreparedStatement;
import java.sql.SQLException;

/**
 * @ClassName DeptMapper
 * @Description 接口实现类
 * @Author wq
 * @Date 2019/1/31 18:05
 * @Version 1.0.0
 */
public class DeptMapper implements SqlSession {
    private PreparedStatement ps;
    public int save(String sql) throws SQLException {
        return ps.executeUpdate(sql);
    }
}

​ 通知

package com.wq.proxy2.service.proxy;

import com.wq.proxy2.service.SqlSession;

import java.lang.reflect.Field;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.PreparedStatement;
import java.sql.SQLException;

/**
 * @ClassName DeptMapperProxy
 * @Description TODO
 * @Author wq
 * @Date 2019/1/31 18:07
 * @Version 1.0.0
 */
public class DeptMapperProxy  implements InvocationHandler {

    private SqlSession sqlSession;

    private PreparedStatement preparedStatement;
    private Connection connection;

    /**
     * 代理对象构造器
     * @param sqlSession   指定需要代理的接口
     */
    public DeptMapperProxy(SqlSession sqlSession){
        this.sqlSession = sqlSession;
    }

    /**
     * 次要业务1:
     *     加载驱动.    建立连接通道.   创建preapredStatement
     * @throws ClassNotFoundException
     * @throws SQLException
     */
    public void init() throws ClassNotFoundException, SQLException {
        Class.forName("com.mysql.jdbc.Driver");
        connection = DriverManager.getConnection("jdbc:mysql://119.23.220.195/kkb", "root", "root");
        preparedStatement = connection.prepareStatement("");
    }

    /**
     * 次要业务2
     *      关闭连接和preparedStatement
     * @throws SQLException
     */
    public void destroy() throws SQLException {
        if (this.preparedStatement != null){
            this.preparedStatement.close();
        }
        if (this.connection != null){
            this.connection.close();
        }
    }

    /**
     * 代理之后的主业务+次要业务逻辑
     * @param proxy
     * @param method
     * @param args
     * @return
     * @throws Throwable
     */
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        init();
        //反射给实现类的preparedStatement赋值
        Field ps = sqlSession.getClass().getDeclaredField("ps");
        ps.setAccessible(true);
        ps.set(sqlSession, this.preparedStatement);
        //执行目标方法
        Object invoke = method.invoke(sqlSession, args);
        destroy();
        return invoke;
    }
}

​ 代理对象生成工厂

package com.wq.proxy2.service.factory;

import com.wq.proxy2.service.SqlSession;
import com.wq.proxy2.service.proxy.DeptMapperProxy;

import java.lang.reflect.Proxy;

/**
 * @ClassName ProxyFactory
 * @Description 代理对象Bean工厂
 * @Author wq
 * @Date 2019/2/1 9:01
 * @Version 1.0.0
 */
public class ProxyFactory {

    /**
     * 代理对象工厂方法
     *
     * @param type
     * @return
     * @throws IllegalAccessException
     * @throws InstantiationException
     */
    public static SqlSession getInstance(Class type) throws IllegalAccessException, InstantiationException {


        //创建呗监控的实例对象
        SqlSession sqlSession = (SqlSession) type.newInstance();

        //创建通知对象
        DeptMapperProxy deptMapperProxy = new DeptMapperProxy(sqlSession);

        //注册JDK代理
        SqlSession sqlSession1 = (SqlSession) Proxy.newProxyInstance(sqlSession.getClass().getClassLoader(), sqlSession.getClass().getInterfaces(), deptMapperProxy);

        return sqlSession1;
    }
}

​ 测试代码

package com.wq.proxy2.service.main;

import com.wq.proxy2.service.SqlSession;
import com.wq.proxy2.service.factory.ProxyFactory;
import com.wq.proxy2.service.impl.DeptMapper;

import java.sql.SQLException;

/**
 * @ClassName TestMain
 * @Description TODO
 * @Author wq
 * @Date 2019/2/1 9:13
 * @Version 1.0.0
 */
public class TestMain {

    public static void main(String[] args) throws InstantiationException, IllegalAccessException, SQLException {
        String sql = "insert into dept(dname,loc,flag)values('shiye','cq',1)";
        SqlSession instance = ProxyFactory.getInstance(DeptMapper.class);
        int i = instance.save(sql);
        System.out.println("i="+i);
    }
}
weiqiang2
关注
Mybatis中的设计模式
Mr.xing的博客
04-05 3796
Builder模式，例如SqlSessionFactoryBuilder、XMLConfigBuilder、XMLMapperBuilder、XMLStatementBuilder、CacheBuilder。工厂模式，例如SqlSessionFactory、ObjectFactory、MapperProxyFactory。单例模式，例如ErrorContext、LogFactory。
什么是面向接口编程？动态代理又是怎么一回事？
weixin_48826996的博客
07-12 298
类中的成员变量设计为接口,方法的形参设计为接口,方法的返回值设计为接口,调用时接口指向实现类。个人理解为一个插板，插板在现实生活中有两种一种是三头、一种是双头，打比方有三头插口，冰箱是三头插头，电脑的插头也是三头，这两个都可使用。冰箱和电脑都可以插在这个三孔插板上，冰箱、电脑都是电器（目标对象）我们的插板只有一个三孔插口， this.是调用类中成员变量（第一个target，后面的this.target是指调用前面的那个target）agent是代理的功能接口指向实现类，实现类是什么，用到的就是什么，那个目标
Mybatis 与 代理模式
CoderLi
05-12 767
我们经常在工作中使用到 AOP 、在设计模式中、它属于代理模式。 代理模式属于一种结构性设计模式、让你能够提供对象的替代品或占位符。代理控制着对于远对象的访问、并允许在将请求提交给对象前后进行一些处理。 JDK 中的动态代理 核心类就是 InvocationHandler Mybatis 中代理模式 也是在日志模块中、 这些代理类从其名字中可以猜测出其用来打印日志 public final class ConnectionLogger extends BaseJdbcLogger implemen.
Mybatis---代理设计模式（超详细）
最新发布
yjp1240201821的博客
09-06 1323
本文主要讲解Mybatis---代理设计模式，从静态代理、动态代理、cglib代理等等帮助深刻理解
Mybatis 代理模式创建
ZQ741552720的博客
03-11 430
mybatis代理模式与非代理模式的区别： mapper类只需要定义接口，mapper映射文件的namespace的值必须为mapper接口的全类名 书写的SQL的ID 必须与mapper接口中的相对应的方法名相同 配置文件mybatisConfig.xml &lt;?xml version="1.0" encoding="UTF-8" ?&gt; &lt;!DOCTYPE conf...
Mybatis代理模式
codingman的博客
09-03 464
1.接口、实现类的形式以前我们开发的形式使用的是接口+实现类的形式进行开发，比如：UserDao UserDaoImpl Dao中的代码存在重复代码，另外 硬编码 不利于后期的项目扩展与维护2.Mapper代理Mapper接口开发方法只需要程序员编写Mapper接口（相当于Dao接口），由Mybatis框架根据接口定义创建接口的动态代理对象，代理对象的方法体同上边Dao接口实现类方法。
【源码分析设计模式 8】mybatis中的代理模式
学Java，找哪吒
06-10 7319
一、基本概念 代理模式给某一个对象提供一个代理对象，并由代理对象控制对原对象的引用。通俗的来讲代理模式就是中介。 想象一下我们生活中购买火车票的情节，我们可以通过飞猪购买，也可以到窗口购买，飞猪就相当于代理模式，秒懂吧？ 二、代理模式的结构 代理是英文proxy翻译过来的，我们生活中最常见的代理，代购，不需解释，都懂。 上图就是代理模式的UML类图。 1、用户只关心接口功能，而不在乎是谁提供了功能，上图中接口subject； 2、接口真正实现者是RealSubject，但是它不与用户直
88丨开源实战五（中）：如何利用职责链与代理模式实现MyBatisPlugin？1
08-03
在本文中，我们将探讨如何利用职责链模式和代理模式实现MyBatisPlugin，这是一种在MyBatis框架中用于扩展和拦截SQL执行过程的方法。首先，我们要理解职责链模式的基本概念，它通常由处理器（Handler）和处理器链...
设计模式在mybatis中的应用
08-08
在MyBatis的核心处理层中，使用了代理模式、构造者模式、配置解析组合模式、SQL解析装饰器模式和模板方法模式等多种设计模式。 代理模式能够控制使用方对RealSubject对象的访问，或是在执行业务逻辑之前执行统一的...
mybatis的代理模式
superliug的博客
10-10 1704
mybatis的代理模式和动态sql 1.代理模式 什么是mybatis的代理模式？ 正如我们大家以前做开发的时候，大家在一般的web开发中都是实现mvc的开发模式的时候，我们大多数都是采用面向接口的开发模式，在这个过程中我们大多都要使用多态来创建接口的实现类的实现形式，这个过程中我们产生了大量的依赖关系，后期我们会从spring的具体案例中给大家具体来分析其具体的减少依赖的过程，我们平时做的有关...
Mybatis 代理模式
lengyingzhang的博客
04-17 3264
1. 代理方式获取Mapper -> getMapper() 思考一个问题，通常的Mapper接口我们都没有实现的方法却可以使用，是为什么呢？答案很简单动态代理。 开始之前介绍一下MyBatis初始化时对接口的处理：MapperRegistry是Configuration中的一个属性，它内部维护一个HashMap用于存放mapper接口的工厂类，每个接口对应一个工厂类。mappers中可以 配置接口的包路径，或者某个具体的接口类。 当解析mappers标签时，它会判断解析到的是mapper配置文件
MyBatis代理模式简析
weixin_46306430的博客
02-25 416
基于mybatis代理模式的一些理解
MyBatis源码分析之——获得Mapper对象
冰河的专栏
01-05 1145
UserMapper userMapper = sqlSession.getMapper(UserMapper.class); public <T> T getMapper(Class<T> type) { return configuration.getMapper(type, this); } mapperRegistry.getMapper是从Mapp...
搞懂MyBatis中设计模式源码——代理模式
热门推荐
shang_0122的博客
05-19 1万+
无代理不框架，无反射不框架； 万字长文，助你理解MyBatis中动态代理源码
MyBatis中的代理模式
zmm0420的专栏
04-28 125
搞懂MyBatis中设计模式源码——代理模式 https://blog.csdn.net/shang_0122/article/details/106105717
代理模式的实际运用-以mybatis拦截器实现原理为例
葵续浅笑的博客
08-16 1235
之前在写mybatis拦截器的时候，因为不懂原理，琢磨了很久，不知道怎么写，在网上找了很多资料，才知道mybatis的拦截器主要还是通过代理实现的，而且我在之前的博文中刚好学习了代理模式。更精细的是，在mybatis对代理的应用上，不管是封装易用性，减少代码耦合度上，都可以让我之前写的代理模式demo进一步改进，也让我加深了对代理模式的理解。之前代理模式博文地址：http://blog.csdn.n
MyBatis原理（四）：MyBatis中代理模式的运用
Gongyl的博客
08-18 797
问题 先来思考几个问题： 为什么我们在mybatis中只需要写一个dao层接口就可以直接调用方法，返回数据库查询结果呢？ 一、JDK动态代理 先说出答案，MyBatis是使用JDK动态代理来设计的： 利用java.lang.reflect.Proxy对象实现，底层用到其实是反射。 被代理对象必须实现接口（因为java类是单继承的，动态代理类在被创建后继承了Proxy类，所以目标对象必须实现接口，其实跟静态代理的条件差不多，只不过通过反射，很多东西可以动态执行，不需要手写） static Obje
Mybatis-代理模式
zxy_spure的博客
07-06 230
Mybatis-代理模式静态代理动态代理-必须有接口 代理模式 需要注意的有下面几点： 用户只关心接口功能，而不在乎谁提供了功能。上图中接口是 Subject。 接口真正实现者是上图的 RealSubject，但是它不与用户直接接触，而是通过代理。 代理就是上图中的 Proxy，由于它实现了 Subject 接口，所以它能够直接与用户接触。 用户调用 Proxy 的时候，Proxy 内部调用了 RealSubject。所以，Proxy 是中介者，它可以增强 RealSubject 操作。 静态代理
Mybatis—代理模式
qwLily的博客
12-28 495
代理模式是一种结构型设计模式，它为其他对象提供一种代理以控制对这个对象的访问。代理类通常在原始对象的基础上提供了一些额外的功能，例如远程访问、安全性控制、延迟加载等。通过使用代理模式，可以在不改变原始对象的情况下增加一些额外的功能，同时也可以对原始对象进行保护和封装。
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值