语雀链接:https://www.yuque.com/nlwrno/xfkcgp/vcw1u4
什么是代理
代理名词
代理对象:增强后的对象
目标对象:被增强的对象
他们不是绝对的,是根据情况变化的
静态代理
继承
// 目标对象
public class IndexDaoImpl {
public void query(){
System.out.println("select db...");
}
}
//代理对象,代理打印日志
public class IndexDaoLogImpl extends IndexDaoImpl {
@Override
public void query() {
System.out.println("console log...");
super.query();
}
}
// 代理验证
public class IndexDaoPowerImpl extends IndexDaoImpl {
@Override
public void query() {
System.out.println("power...");
super.query();
}
}
/*
* 模拟查询加日志
* 1、加在查询方法处,但有可能IndexDao是引入class文件,不能直接添加
* 2、加在调用方法处,但调用可能调用很多次,代码侵入性/冗余度太高
* 3、静态代理
* 继承:代理对象继承目标对象
* 聚合:
* 4、动态代理
* */
*
// 继承方式
public class Test {
public static void main(String[] args) {
IndexDaoLogImpl log = new IndexDaoLogImpl();
log.query();
//IndexDaoImpl indexDao = new IndexDaoImpl();
//indexDao.query();
}
}
聚合
public interface IndexDao {
public void query();
}
// 目标对象
public class IndexDaoImpl implements IndexDao {
public void query(){
System.out.println("select db...");
}
}
// 代理对象
public class IndexDaoLogImpl implements IndexDao {
private IndexDao dao;
public IndexDaoLogImpl(IndexDao dao){
this.dao = dao;
}
public void query() {
System.out.println("console log...");
dao.query();
}
}
// 代理对象
public class IndexDaoPowerImpl implements IndexDao {
private IndexDao dao;
public IndexDaoPowerImpl(IndexDao dao){
this.dao = dao;
}
@Override
public void query() {
System.out.println("power...");
dao.query();
}
}
public class Test {
public static void main(String[] args) {
IndexDao dao = new IndexDaoImpl();
IndexDao dao1 = new IndexDaoLogImpl(dao);
dao1.query();
}
}
这时候就会出现一个问题,是继承好还是聚合好,为什么?
从两幅图种可以观察到,如果我们的代理需要增加,比如,我们即需要log代理,又需要power代理,这个时候,继承和聚合是怎么实现的呢?
**继承:**我们不能修改原先的代理,如果又修改了,我们只需要power代理时,则又要改动,所以只能增加一个新的代理。可以说是链式代理。
**聚合:**只需要将log代理传入到log代理中即可
那如果这时候来了个变态需求,需要log代理和power代理顺序也又要求,继承/类又要增加,这时候就要疯了。这时候还会出现类爆炸,一直增加类。相对来说,聚合就好很多,但如果要求又很多代理,依然会产生类爆炸,只是相对继承来说好一点。
总结:如果在不确定的情况下,尽量不去使用静态代理。因为一旦写代码就会产生类,一直产生类就会发生类爆炸。所谓不确定,就是不知道后续要不要进行扩展,就像需求中所说的,log代理之后有没有可能会出来power不确定。所以这种情况最好不要使用静态代理,从而引出了动态代理。
手动实现代理
那我们知道了上面的缺点,我们自己实现代理的话会如何去做呢?
- 生成java文件
- 编译Java文件,生成.class
- 通过.class创建Proxy代理对象
Proxy生成
/**
* @Description TODO
* @ClassName ProxyUtil.java
* @Author yangkai
* @CreateTime 2020年03月19日 14:09:00
* @Version 1.0
* @History
**/
package com.proxy.util;
import javax.tools.JavaCompiler;
import javax.tools.StandardJavaFileManager;
import javax.tools.ToolProvider;
import java.io.File;
import java.io.FileWriter;
import java.io.IOException;
import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.net.URL;
import java.net.URLClassLoader;
public class ProxyUtil {
/*
* content ----> string
* .java io
* .class
* new
* return
* */
public static Object newInstance(Class clazz, MineInvocationHandler h) throws IOException, ClassNotFoundException, NoSuchMethodException, IllegalAccessException, InvocationTargetException, InstantiationException {
Object proxy = null;
// Class<?> clazz = clz.getInterfaces()[0];
Method[] methods = clazz.getDeclaredMethods();
String line = "\r\n";
String tab = "\t";
String infName = clazz.getSimpleName();
String content = "";
String packageContent = "package com.google;"+line;
String importContent = "import "+clazz.getName()+";"+line
+ "import com.proxy.util.MineInvocationHandler;"+line
+ "import java.lang.reflect.Method;"+line;
String clazzFirstLineContent = "public class $Proxy implements "+infName+"{"+line;
String fileContent = tab+"private MineInvocationHandler h;"+line;
String constructContent = tab+"public $Proxy(MineInvocationHandler h){"+line
+tab + tab + "this.h = h;"+line
+tab + tab +"}"+line;
String methodContent = "";
for (Method method : methods) {
String returnTypeName = method.getReturnType().getName();
String methodName = method.getName();
Object args[] = method.getParameterTypes();
String argsContents ="";
String paramsContents = "";
String argNames="";
for (int i=0;i<args.length;i++) {
String argName = ((Class) args[0]).getName();
argNames = argName+".class,";
argsContents += argName+" p"+i+",";
paramsContents+="p"+i+",";
}
if(argsContents.length()>0){
argNames = ","+argNames.substring(0,argNames.length()-1);
argsContents = argsContents.substring(0,argsContents.length()-1);
paramsContents = ",new Object[]{"+paramsContents.substring(0,paramsContents.length()-1)+"}";
}else{
paramsContents=",null";
}
methodContent += tab+"public "+returnTypeName+" "+methodName +"("+argsContents+"){"+line
+tab+tab+"try{"+line
+tab+tab+tab + "Method method = Class.forName(\""+clazz.getName()+"\").getDeclaredMethod(\""+methodName+"\""+argNames+");"+line;
if ("void".equals(returnTypeName)){
methodContent+=tab+tab+tab +"h.invoke(new $Proxy(h),method"+paramsContents+");"+line
+tab+tab+"}catch ( Throwable e){"+line
+tab+tab+tab+"e.printStackTrace();"+line
+tab+tab+"}"+line
+tab+"}"+line;
}else{
methodContent+=tab+tab+tab +"return ("+returnTypeName+")h.invoke(new $Proxy(h),method"+paramsContents+");"+line
+tab+tab+"}catch ( Throwable e){"+line
+tab+tab+tab+"e.printStackTrace();"+line
+tab+tab+"}"+line
+tab+tab+"return null;"+line
+tab+"}"+line;
}
}
content=packageContent+importContent+clazzFirstLineContent+fileContent+constructContent+methodContent+"}";
File file = new File("G:/com/google");
if(!file.exists()){
file.mkdirs();
}
file = new File("G:/com/google/$Proxy.java");
FileWriter fileWriter = new FileWriter(file);
fileWriter.write(content);
fileWriter.flush();
fileWriter.close();
JavaCompiler compiler = ToolProvider.getSystemJavaCompiler();
StandardJavaFileManager standardFileManager = compiler.getStandardFileManager(null,null,null);
Iterable utils = standardFileManager.getJavaFileObjects(file);
JavaCompiler.CompilationTask task = compiler.getTask(null, standardFileManager, null, null, null,utils);
task.call(); // 这里仅使用jre会抛异常,使用jdk
standardFileManager.close();
// compiler.run(null,null,null,"G:/com/google/$Proxy.java");
URL[] urls = new URL[]{new URL("file:G:\\\\")};
URLClassLoader urlClassLoader = new URLClassLoader(urls);
Class claz = urlClassLoader.loadClass("com.google.$Proxy");
Constructor constructor = claz.getConstructor(MineInvocationHandler.class);
proxy = constructor.newInstance(h);
return proxy;
}
}
InvocationHandler
/**
* @Description TODO
* @ClassName InvocatetionHandler.java
* @Author yangkai
* @CreateTime 2020年03月20日 15:03:00
* @Version 1.0
* @History
**/
package com.proxy.util;
import java.lang.reflect.Method;
public interface MineInvocationHandler {
public Object invoke(Object proxy, Method method, Object[] args)
throws Throwable;
}
测试动态代理
/**
* @Description TODO
* @ClassName IndexDao.java
* @Author yangkai
* @CreateTime 2020年03月19日 11:50:00
* @Version 1.0
* @History
**/
package com.proxy.proxy1;
public interface IndexDao {
public void query();
public String selectStr();
public String queryName(String name);
}
/**
* @Description TODO
* @ClassName IndexDao.java
* @Author yangkai
* @CreateTime 2020年03月19日 11:28:00
* @Version 1.0
* @History
**/
package com.proxy.dao;
import com.proxy.proxy1.IndexDao;
public class IndexDaoImpl implements IndexDao {
public void query(){
System.out.println("select db...");
}
public String selectStr() {
System.out.println("IndexDaoImpl selectStr");
return "IndexDaoImpl";
}
@Override
public String queryName(String name) {
return name;
}
}
/**
* @Description TODO
* @ClassName TestInvokeHandle.java
* @Author yangkai
* @CreateTime 2020年03月20日 15:05:00
* @Version 1.0
* @History
**/
package com.proxy.util;
import java.lang.reflect.Method;
public class TestInvokeHandle implements MineInvocationHandler {
Object target;
public TestInvokeHandle(Object target){
this.target= target;
}
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
System.out.println("代理");
return method.invoke(target,args);
}
}
public class Test {
public static void main(String[] args) throws Exception {
IndexDao proxy = (IndexDao) ProxyUtil.newInstance(IndexDao.class,new TestInvokeHandle(new IndexDaoImpl()));
proxy.query();
proxy.selectStr();
String s = proxy.queryName("测试....");
System.out.println(s);
}
}
JDK动态代理
流程图
测试JDK动态代理
public interface IndexDao {
public void query();
public String selectStr();
public String queryName(String name);
}
/**
* @Description TODO
* @ClassName IndexDao.java
* @Author yangkai
* @CreateTime 2020年03月19日 11:28:00
* @Version 1.0
* @History
**/
package com.proxy.dao;
import com.proxy.proxy1.IndexDao;
public class IndexDaoImpl implements IndexDao {
public void query(){
System.out.println("select db...");
}
public String selectStr() {
System.out.println("IndexDaoImpl selectStr");
return "IndexDaoImpl";
}
@Override
public String queryName(String name) {
return name;
}
}
/**
* @Description TODO
* @ClassName MyInvoketionHandle.java
* @Author yangkai
* @CreateTime 2020年03月20日 14:37:00
* @Version 1.0
* @History
**/
package com.proxy.util;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
public class MyInvoketionHandle implements InvocationHandler {
Object target;
public MyInvoketionHandle(Object target){
this.target = target;
}
/**
*
* @param proxy 代理对象
* @param method 目标对象的方法
* @param args 目标方法的参数
* @return
* @throws Throwable
*/
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
System.out.println("proxy invoke...");
return method.invoke(target,args);
}
}
/**
* @Description TODO
* @ClassName Test.java
* @Author yangkai
* @CreateTime 2020年03月19日 11:29:00
* @Version 1.0
* @History
**/
package com.proxy.test;
//开闭原则
// 单一职责
import com.proxy.dao.IndexDaoImpl;
import com.proxy.proxy.IndexDaoLogImpl;
import com.proxy.proxy1.IndexDao;
import com.proxy.util.MyInvoketionHandle;
import com.proxy.util.ProxyUtil;
import com.proxy.util.TestInvokeHandle;
import java.io.IOException;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
/*
* 模拟查询加日志
* 1、加在查询方法处,但有可能IndexDao是引入class文件,不能直接添加
* 2、加在调用方法处,但调用可能调用很多次,代码侵入性/冗余度太高
* 3、静态代理
* 继承:代理对象继承目标对象
* 聚合:
* 4、动态代理
* */
public class Test {
public static void main(String[] args) throws Exception {
IndexDao proxy1 = (IndexDao)Proxy.newProxyInstance(Test.class.getClassLoader(),
new Class[]{IndexDao.class}, new MyInvoketionHandle(new IndexDaoImpl()));
proxy1.query();
proxy1.selectStr();
String s = proxy1.queryName("测试....");
System.out.println(s);
}
}
/*
* 代理对象 增强后的对象
* 目标对象 被代理的对象
* */
源码解析
后续增加…