概述
我们首先要理解，代理模式是干什么的？我们知道，代理模式是用于松耦合的，其实代理模式是通过将主要业务与次要业务分开处理实现松耦合的。而代理模式的本质是在监控行为特征。
代理模式
代理模式主要分两种，静态代理模式和动态代理模式，下面我们通过实现来看看两者的具体区别到底是什么。
静态代理模式
主要角色：
接口（主题）：定义需要被监控的方法
被代理类：接口的具体实现类
代理类：代理被代理类的类
主要角色：
1. 代理类和被代理类实现同一个主题接口。
2. 代理类具备一个属性，为被代理类对象。
实现的目的：
核心业务逻辑由被代理类去实现，非核心需求多变的逻辑，交给代理类实现。
代码实现案例：
接口（主题）
public interface Proxy {
public abstract void todo();
}
被代理类
public class Reality implements Proxy {
@Override
public void todo() {
System.out.println("我是核心功能......");
}
}
代理类
public class ProxyReality implements Proxy {
// 被代理对象
private Proxy reality;
//传入一个被代理对象
public ProxyRole(Proxy proxy) {
reality = proxy;
}
@Override
public void todo() {
//1. 代理类的前期准备
doBefore();
//2. 执行核心功能
reality.todo();
//3. 代理类的收尾工作
doAfter();
}
private void doBefore() {
System.out.println("我做非核心功能......");
}
private void doAfter() {
System.out.println("我是多变的需求......");
}
}
案例测试
public static void main(String[] args) {
//1. 创建被代理对象
Proxy reality = new RealityRole();
//2. 创建代理对象，传入被代理对象
ProxyRole proxyRole = new ProxyRole(reality);
//3. 代理对象执行
proxyRole.todo();
}
总结：
- 代理类和被代理类实现一样的接口。
- 代理类具有一个属性对象，值为被代理类。
- 执行时，调用代理类，再由代理类调用被代理类。
动态代理模式
主要角色：
接口（主题）：定义需要被监控的方法
被代理类：接口的具体实现类
通知类：包含次要业务的具体实现和次要与主要的绑定
监控对象（代理对象）：被监控实例对象，需要被监控的监控行为，具体通知类实例对象
实现的思路：
1. 采用通知类的方式，通知类具备一个属性，为被代理类对象。
2. 使用JDK的给通知类分配一个监控对象。
3. 通知类统一实现InvocationHandler接口。
实现的目的：
核心业务逻辑由被代理类去实现，非核心需求多变的逻辑，交给通知类实现，不需要一个具体的代理类，而是由JDK动态生成代理对象。
JDK方式代码实现案例：
接口（主题）
public interface Proxy {
public abstract void todo();
}
被代理类
public class Reality implements Proxy {
@Override
public void todo() {
System.out.println("我是核心功能......");
}
}
通知类
public class ProxyReality implements InvocationHandler {
// 被代理对象
private Proxy reality;
//传入一个被代理对象
public ProxyRole(Proxy proxy) {
reality = proxy;
}
/**
* 在被监控的方法要被执行时，执行该方法
* @param proxy 代理对象，例如小明.eat()
* @param method 类似eat方法的封装对象
* @param args 入参的数组
*/
public Object invoke(Object proxy, Method method, Object[] args) {
//0.接受主要业务返回的对象
Object resultObj;
//1. 代理类的前期准备
doBefore();
//2. 执行核心功能
resultObj = method.invoke(proxy,args);
//3. 代理类的收尾工作
doAfter();
return resultObj;
}
private void doBefore() {
System.out.println("我做非核心功能......");
}
private void doAfter() {
System.out.println("我是多变的需求......");
}
}
代理工厂类
public class ProxyFactory {
/**
* JDK动态代理模式下，代理对象的数据类型应由监控行为来描述
* @param obj 监控的类
* @return
*/
public static Proxy builder(Class obj) throws IllegalAccessException, InstantiationException {
//1.实例化被监控对象
Proxy $proxy= (Proxy) obj.newInstance();
//2.实例化通知对象，将被监控对象传入
InvocationHandler adviser = new ProxyReality($proxy);
//2、向JVM申请一个负责监控被监控对象的代理对象
Proxy proxy = (Proxy) Proxy.newProxyInstance($proxy.getClass().getClassLoader(),
$proxy.getClass().getInterfaces(),adviser);
return proxy;
}
}
案例测试
public static void main(String[] args) {
//1. 创建被代理对象
Proxy reality = ProxyFactory.builder(Reality.class);
//2. 直接调用代理对象方法执行
reality.todo();
}
MyBatis的动态代理模式
一、JDBC开发步骤
public void test(){
Connection con = null;
PreparedStatement ps = null;
ResultSet rs = null;
try {
//1. 加载驱动
Class.forName("com.mysql.jdbc.Driver");
//2. 建立链接通道
con = DriverManager.getConnection("jdbc:mysql://localhost:3306/mybatis", "root", "root");
//3. 建立PreparedStament
ps = con.prepareStatement("SELECT * FROM ...");
//4. 输送SQL命令到数据库中执行，并带回运行结果
rs = ps.executeQuery();
} catch (ClassNotFoundException e) {
e.printStackTrace();
} catch (SQLException e) {
e.printStackTrace();
}finally {
// 5. 销毁链接通道、PreparedStament和结果集对象
try {
if (rs != null) {
rs.close();
rs = null;
}
if (ps != null) {
ps.close();
ps = null;
}
if (con != null) {
con.close();
con = null;
}
} catch (SQLException e) {
e.printStackTrace();
}
}
}
二、MyBatis动态代理模式封装JDBC
1、JDBC的主要业务和次要业务
主要业务：输送SQL命令到数据库中执行，并带回运行结果
次要业务：加载驱动、建立链接通道、建立PreparedStament和销毁链接通道和PreparedStament
2、声明接口SqlSession（定义具体的方法行为）
/**
* 定义被监控者接口
*/
public interface SqlSession {
public int insert(String template,Object obj) throws SQLException;
public int update(String template,Object obj) throws SQLException;
public void delete(String template,Object obj) throws SQLException;
public Object queryInfo(String template,Object obj) throws SQLException;
}
3、具体实现类被监控对象
主要业务：具体实现SQL命令执行
/**
* 被监控对象实现
*/
public class SimpleSqlSession implements SqlSession {
ParamentHandler parament;//入参处理器
StatementHandler statement;//执行命令处理器
ResultSetHandler resultSet;//结果集处理器
PreparedStatement ps;
/**
* 初始化处理器
*/
public SimpleSqlSession(){
this.resultSet = new SimpleResultSetHandler();
this.statement = new SimpleStatementHandler();
this.parament = new SimpleParmentHandler();
}
public int insert(String template,Object obj) throws SQLException {
String sql = parament.insert(template,obj);
return statement.update(ps,sql);
}
public int update(String template,Object obj) throws SQLException {
String sql = parament.insert(template,obj);
return statement.update(ps,sql);
}
public void delete(String template,Object obj) throws SQLException {
String sql = parament.insert(template,obj);
statement.update(ps,sql);
}
public Object queryInfo(String template,Object obj) throws SQLException {
String sql = parament.insert(template,obj);
ResultSet object = statement.query(ps,sql);
return resultSet.query(object);
}
}
/**
* 参数处理器接口
*/
public interface ParamentHandler{
public String insert(String template,Object paremt);
public String delete(String template,Object paremt);
public String update(String template,Object paremt);
public String query(String template,Object paremt);
}
/**
* 参数处理器具体实现
*/
public class SimpleParmentHandler implements ParamentHandler {
/**
* 新增的参数处理
*/
public String insert(String template, Object paremt) {
String sql = null;
//拼接入参和SQL模板
return sql;
}
/**
* 删除的参数处理
*/
public String delete(String template, Object paremt) {
String sql = null;
//拼接入参和SQL模板
return sql;
}
/**
* 更新的参数处理
*/
public String update(String template, Object paremt) {
String sql = null;
//拼接入参和SQL模板
return sql;
}
/**
* 查询的参数处理
*/
public String query(String template, Object paremt) {
String sql = null;
//拼接入参和SQL模板
return sql;
}
}
/**
* 命令执行处理器接口
*/
public interface StatementHandler{
public int update(PreparedStatement ps,String sql) throws SQLException;
public ResultSet query(PreparedStatement ps, String sql) throws SQLException;
}
/**
* 命令执行处理器具体实现
*/
public class SimpleStatementHandler implements StatementHandler{
/**
* 执行更新指令
*/
public int update(PreparedStatement ps,String sql) throws SQLException {
return ps.executeUpdate(sql);
}
/**
* 执行查询指令
*/
public ResultSet query(PreparedStatement ps, String sql) throws SQLException {
return ps.executeQuery(sql);
}
}
/**
* 返回参数格式化处理器接口
*/
public interface ResultSetHandler {
public Object query(ResultSet resultSet) throws SQLException;
}
/**
* 返回参数格式化处理器具体实现
*/
public class SimpleResultSetHandler implements ResultSetHandler{
public Object query(ResultSet resultSet) throws SQLException {
//格式化为具体对象（反射赋值）
resultSet.close();
resultSet = null;
return null;
}
}
4、通知类：实现InvocationHandler，在构造方法定义具体入参SqlSession，实现具体次要业务。
/**
* 通知类（实现次要业务）
*/
public class Plugin implements InvocationHandler {
SqlSession session;
Connection con = null;
PreparedStatement ps = null;
public Plugin(SqlSession session){
this.session = session;
}
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
//1. 传值给会话对象
setPreparedStatement();
//2. 前置处理
frontLoad();
//3. 执行主要业务
Object result = method.invoke(session,args);
//4. 后置处理
closeLoad();
return result;
}
/**
* 反射赋值
*/
private void setPreparedStatement() throws NoSuchFieldException, IllegalAccessException {
Field field = session.getClass().getDeclaredField("ps");
field.setAccessible(true);
field.set(session,ps);
}
/**
* 前置处理
* @throws Exception
*/
private void frontLoad() throws Exception {
Class.forName("com.mysql.jdbc.Driver");
con = DriverManager.getConnection("jdbc:mysql://localhost:3306/mybatis", "root", "root");
ps = con.prepareStatement("");
}
/**
* 后置处理
* @throws SQLException
*/
private void closeLoad() throws SQLException {
if (ps != null) {
ps.close();
ps = null;
}
if (con != null) {
con.close();
con = null;
}
}
}
5、实现代理工厂SqlSessionFactory
/**
* 代理工厂
*/
public class SqlSessionFactory {
/**
* JDK动态代理模式下，代理对象的数据类型应由监控行为来描述
* @param obj 监控的类
* @return
*/
public static SqlSession builder(Class obj) throws IllegalAccessException, InstantiationException {
//1.创建被监控对象
SqlSession session = (SqlSession) obj.newInstance();
//2.创建通知对象
InvocationHandler adviser = new Plugin(session);
//2、向JVM申请一个负责监控被监控对象的代理对象
SqlSession proxy = (SqlSession) Proxy.newProxyInstance(session.getClass().getClassLoader(),
session.getClass().getInterfaces(),adviser);
return proxy;
}
}
网友评论