Java基础加强，对象的三种增强方式，重点学习动态代理设计模式（为spring框架打基础）
技术分析: 动态代理
面试题: 问 增强一个对象的方法有几种方式?
1 继承
条件: 得知道要继承的类是谁
2 装饰者模式
不需要知道父类是谁 只需要知道接口即可
条件:
1 装饰者和被装饰需要实现同一个接口
2 装饰者有被装饰者的引用
100方法---适配器类
缺点: 工作量大
3 动态代理
代理的概念: 图
条件:
1 必须得知道要被代理的类/对象是谁
动态代理:动态的给我们生成代理类/代理对象
动态: 这个东西我们不用写,java已经给我们提供好了
JDK的动态代理:
Proxy.newProxyInstance(ClassLoader loader, Class<?>[] interfaces, InvocationHandler h)
返回一个指定接口的代理类实例
扩展: CGLIB的动态代理(导包)
要求:
1 动态里的概念和作用
2 JDK的动态代理方式代码能写出来 (案例写出来)
// 后期的框架是封装好的 但是建议写出来
细节1 :
proxyPerson.run(); // 执行这个方法 invoke都会执行一遍 执行的内容就是针对该方法的增强
细节4:
判断 只对某个方法增强 别的方法不增强
细节2:
返回值 return 谁调用返回给谁 返回的内容就是最终值
细节3:
参数的问题
总结: 给我一个对象.我就可以对这个对象的接口所有方法进行增强
1，继承的方式实现对象增强
接口
package com.it.extendsObject;
public interface Person {
public void run();
}
被增强对象
package com.it.extendsObject;
public class puTongPerson implements Person {
//普通人
@Override
public void run() {
System.out.println("跑。。。");
}
}
增强的对象
package com.it.extendsObject;
public class SupPerson extends puTongPerson {
//超人
@Override
public void run() {
super.run();
System.out.println("增强了：飞。。。。");
}
}
测试类
package com.it.extendsObject;
import org.junit.Test;
public class demo1 {
@Test
public void test() {
puTongPerson p=new puTongPerson();
// 需求:对普通人的走方法进行增强 由走变成飞---增强一个对象的方法
// 用继承来实现需求
SupPerson sp=new SupPerson();
sp.run();
}
}
结果
2.使用装饰者模式进行对象增强
如果接口里面有多个方法，装饰着模式工作量巨大，需要全部重写里面的方法
解决方式：使用动态代理来增强对象
接口
package com.it.DecoratorPattern;
public interface Person {
public void run();
// public void run1();
// public void run2();
// public void run3();
// public void run4();
// public void run5();
// public void run6();
}
被增强对象
package com.it.DecoratorPattern;
public class puTongPerson implements Person {
//普通人
@Override
public void run() {
System.out.println("跑。。。");
}
// @Override
// public void run1() {
// // TODO Auto-generated method stub
//
// }
//
// @Override
// public void run2() {
// // TODO Auto-generated method stub
//
// }
//
// @Override
// public void run3() {
// // TODO Auto-generated method stub
//
// }
//
// @Override
// public void run4() {
// // TODO Auto-generated method stub
//
// }
//
// @Override
// public void run5() {
// // TODO Auto-generated method stub
//
// }
//
// @Override
// public void run6() {
// // TODO Auto-generated method stub
//
// }
}
增强的对象
package com.it.DecoratorPattern;
public class SupPerson implements Person {
private puTongPerson p;
// 被装饰者的引用
// 如果person接口里面又多个方法，装饰着模式工作量巨大，需要全部重写里面的方法
// 解决方式：使用动态代理来增强对象
public SupPerson(puTongPerson p) {
this.p=p;
}
public SupPerson() {
super();
// TODO Auto-generated constructor stub
}
@Override
public void run() {
// TODO Auto-generated method stub
p.run();
System.out.println("增强了：飞。。。");
}
// @Override
// public void run1() {
// // TODO Auto-generated method stub
//
// }
// @Override
// public void run2() {
// // TODO Auto-generated method stub
//
// }
// @Override
// public void run3() {
// // TODO Auto-generated method stub
//
// }
// @Override
// public void run4() {
// // TODO Auto-generated method stub
//
// }
// @Override
// public void run5() {
// // TODO Auto-generated method stub
//
// }
// @Override
// public void run6() {
// // TODO Auto-generated method stub
//
// }
}
测试类
package com.it.DecoratorPattern;
import org.junit.Test;
public class demo2 {
@Test
public void test() {
puTongPerson p = new puTongPerson();
// 假装不知道实现类 但是由需要对普通人的run方法进行增强
// 装饰者解决这样的需要
// 条件 : 1 装饰者和被装饰者实现同一个接口 Person
// 2 装饰者里面有被装饰者的引用 在我出生的时候,你把你给我 我要对你进行增强
SupPerson sp=new SupPerson(p);
sp.run();
}
}
3.动态代理设计模式
接口
package com.it.DynamicProxy;
public interface Person {
public void run();
public String sleep();
public String eat(String ss);
}
package com.it.DynamicProxy;
被增强的对象
public class puTongPerson implements Person {
//普通人
@Override
public void run() {
System.out.println("跑。。。");
}
@Override
public String sleep() {
System.out.println("睡着了");
return "sleep";
}
@Override
public String eat(String ss) {
System.out.println("吃了："+ss);
return "吃饱了";
}
}
测试类
package com.it.DynamicProxy;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
import org.junit.Test;
public class demo3 {
@Test
public void text() {
// 要被增强的对象
final puTongPerson p=new puTongPerson();
// 需求: 使用动态代理的方式对普通人进行增强
// jdk提供的类和方法可以给咱们动态的生成代理对象/增强对象 不需要自己去创建增强类
/*参数概述: 固定死的
* 参数1: 和要被增强的对象一样的类加载器
* 参数2: 和要被增强的对象一样的接口
* 1 根据指定的传递接口 返回一个该接口下的实例
* 2 传递的接口 里面的方法就是可以被增强的所有方法
*
* 参数3: 所有的增强业务逻辑实现 (方法)
* */
Person ps = (Person) Proxy.newProxyInstance(
p.getClass().getClassLoader(),
p.getClass().getInterfaces(),
new InvocationHandler() {//匿名内部类
/*参数概述 固定死的
* 参数1:不用管 永远是固定值 代理对象的类型
* 参数2: 要被增强的方法
* 参数3: 要被增强的方法运行过程中需要的参数
* */
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
// TODO Auto-generated method stub
//判断是否是需要增强的方法
if ("eat".equals(method.getName())) {
// 让以前的方法执行
// 参数1:本身应该执行这个方法的对象
// 参数2: 执行这个方法需要的参数
Object invoke = method.invoke(p, args);
System.out.println(invoke);
// 写增强业务逻辑
System.out.println("增强了：飞....");
// 最终返回值 谁调用返回给谁
return "飞起来了";
}else {
return "abcd";
}
}
});
ps.run();// 执行这个方法 invoke都会执行一遍 执行的内容就是针对该方法的增强
String sleep = ps.sleep();
//System.out.println(sleep);
String eat = ps.eat("汉堡");
System.out.println(eat);
}
}
结果：